chrome/browser/chromeos/login/existing_user_controller_browsertest.cc

   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 #include <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/command_line.h"
  11 #include "base/location.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/run_loop.h"
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #include "chrome/browser/chromeos/login/authenticator.h"
  16 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  17 #include "chrome/browser/chromeos/login/helper.h"
  18 #include "chrome/browser/chromeos/login/mock_authenticator.h"
  19 #include "chrome/browser/chromeos/login/mock_login_display.h"
  20 #include "chrome/browser/chromeos/login/mock_login_display_host.h"
  21 #include "chrome/browser/chromeos/login/mock_login_utils.h"
  22 #include "chrome/browser/chromeos/login/mock_url_fetchers.h"
  23 #include "chrome/browser/chromeos/login/mock_user_manager.h"
  24 #include "chrome/browser/chromeos/login/user_manager.h"
  25 #include "chrome/browser/chromeos/login/wizard_controller.h"
  26 #include "chrome/browser/chromeos/policy/device_local_account.h"
  27 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
  28 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
  29 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
  30 #include "chrome/browser/chromeos/settings/cros_settings.h"
  31 #include "chrome/browser/policy/browser_policy_connector.h"
  32 #include "chrome/common/chrome_switches.h"
  33 #include "chrome/test/base/testing_browser_process.h"
  34 #include "chrome/test/base/testing_profile.h"
  35 #include "chrome/test/base/ui_test_utils.h"
  36 #include "chromeos/chromeos_switches.h"
  37 #include "chromeos/dbus/fake_session_manager_client.h"
  38 #include "chromeos/settings/cros_settings_names.h"
  39 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
  40 #include "components/policy/core/common/cloud/cloud_policy_core.h"
  41 #include "components/policy/core/common/cloud/cloud_policy_store.h"
  42 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
  43 #include "components/policy/core/common/cloud/policy_builder.h"
  44 #include "content/public/test/mock_notification_observer.h"
  45 #include "content/public/test/test_utils.h"
  46 #include "google_apis/gaia/mock_url_fetcher_factory.h"
  47 #include "grit/generated_resources.h"
  48 #include "testing/gmock/include/gmock/gmock.h"
  49 #include "testing/gtest/include/gtest/gtest.h"
  50 #include "ui/base/l10n/l10n_util.h"
  51
  52 using ::testing::AnyNumber;
  53 using ::testing::Invoke;
  54 using ::testing::InvokeWithoutArgs;
  55 using ::testing::Return;
  56 using ::testing::ReturnNull;
  57 using ::testing::Sequence;
  58 using ::testing::WithArg;
  59 using ::testing::_;
  60
  61 namespace em = enterprise_management;
  62
  63 namespace chromeos {
  64
  65 namespace {
  66
  67 const char kUsername[] = "test_user@gmail.com";
  68 const char kNewUsername[] = "test_new_user@gmail.com";
  69 const char kPassword[] = "test_password";
  70
  71 const char kPublicSessionAccountId[] = "public_session_user@localhost";
  72 const int kAutoLoginNoDelay = 0;
  73 const int kAutoLoginShortDelay = 1;
  74 const int kAutoLoginLongDelay = 10000;
  75
  76
  77 ACTION_P2(CreateAuthenticator, username, password) {
  78   return new MockAuthenticator(arg0, username, password);
  79 }
  80
  81 }  // namespace
  82
  83 class ExistingUserControllerTest : public policy::DevicePolicyCrosBrowserTest,
  84                                    public testing::WithParamInterface<bool> {
  85  protected:
  86   ExistingUserControllerTest()
  87       : mock_login_display_(NULL), mock_user_manager_(NULL) {}
  88
  89   ExistingUserController* existing_user_controller() {
  90     return ExistingUserController::current_controller();
  91   }
  92
  93   const ExistingUserController* existing_user_controller() const {
  94     return ExistingUserController::current_controller();
  95   }
  96
  97   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
  98     SetUpSessionManager();
  99
 100     DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
 101
 102     mock_login_utils_ = new MockLoginUtils();
 103     LoginUtils::Set(mock_login_utils_);
 104     EXPECT_CALL(*mock_login_utils_, DelegateDeleted(_))
 105         .Times(1);
 106
 107     mock_login_display_host_.reset(new MockLoginDisplayHost());
 108     mock_login_display_ = new MockLoginDisplay();
 109     SetUpLoginDisplay();
 110   }
 111
 112   virtual void SetUpSessionManager() {
 113   }
 114
 115   virtual void SetUpLoginDisplay() {
 116     EXPECT_CALL(*mock_login_display_host_.get(), CreateLoginDisplay(_))
 117         .Times(1)
 118         .WillOnce(Return(mock_login_display_));
 119     EXPECT_CALL(*mock_login_display_host_.get(), GetNativeWindow())
 120         .Times(1)
 121         .WillOnce(ReturnNull());
 122     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
 123         .Times(1);
 124     EXPECT_CALL(*mock_login_display_, Init(_, false, true, true))
 125         .Times(1);
 126   }
 127
 128   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 129     command_line->AppendSwitch(switches::kLoginManager);
 130     if (GetParam())
 131       command_line->AppendSwitch(::switches::kMultiProfiles);
 132   }
 133
 134   virtual void SetUpUserManager() {
 135     // Replace the UserManager singleton with a mock.
 136     mock_user_manager_ = new MockUserManager;
 137     user_manager_enabler_.reset(
 138         new ScopedUserManagerEnabler(mock_user_manager_));
 139     EXPECT_CALL(*mock_user_manager_, IsKnownUser(kUsername))
 140         .Times(AnyNumber())
 141         .WillRepeatedly(Return(true));
 142     EXPECT_CALL(*mock_user_manager_, IsKnownUser(kNewUsername))
 143         .Times(AnyNumber())
 144         .WillRepeatedly(Return(false));
 145     EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
 146         .Times(AnyNumber())
 147         .WillRepeatedly(Return(false));
 148     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
 149         .Times(AnyNumber())
 150         .WillRepeatedly(Return(false));
 151     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsDemoUser())
 152         .Times(AnyNumber())
 153         .WillRepeatedly(Return(false));
 154     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsPublicAccount())
 155         .Times(AnyNumber())
 156         .WillRepeatedly(Return(false));
 157     EXPECT_CALL(*mock_user_manager_, IsSessionStarted())
 158         .Times(AnyNumber())
 159         .WillRepeatedly(Return(false));
 160     EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
 161         .Times(AnyNumber())
 162         .WillRepeatedly(Return(false));
 163     EXPECT_CALL(*mock_user_manager_, Shutdown())
 164         .Times(1);
 165     EXPECT_CALL(*mock_user_manager_, GetProfileByUser(_))
 166         .Times(AnyNumber())
 167         .WillRepeatedly(Return(testing_profile_.get()));
 168   }
 169
 170   virtual void SetUpOnMainThread() OVERRIDE {
 171     testing_profile_.reset(new TestingProfile());
 172     SetUpUserManager();
 173     existing_user_controller_.reset(
 174         new ExistingUserController(mock_login_display_host_.get()));
 175     ASSERT_EQ(existing_user_controller(), existing_user_controller_.get());
 176     existing_user_controller_->Init(UserList());
 177     profile_prepared_cb_ =
 178         base::Bind(&ExistingUserController::OnProfilePrepared,
 179                    base::Unretained(existing_user_controller()),
 180                    testing_profile_.get());
 181   }
 182
 183   virtual void CleanUpOnMainThread() OVERRIDE {
 184     // ExistingUserController must be deleted before the thread is cleaned up:
 185     // If there is an outstanding login attempt when ExistingUserController is
 186     // deleted, its LoginPerformer instance will be deleted, which in turn
 187     // deletes its OnlineAttemptHost instance.  However, OnlineAttemptHost must
 188     // be deleted on the UI thread.
 189     existing_user_controller_.reset();
 190     DevicePolicyCrosBrowserTest::InProcessBrowserTest::CleanUpOnMainThread();
 191     testing_profile_.reset(NULL);
 192     user_manager_enabler_.reset();
 193   }
 194
 195   // ExistingUserController private member accessors.
 196   base::OneShotTimer<ExistingUserController>* auto_login_timer() {
 197     return existing_user_controller()->auto_login_timer_.get();
 198   }
 199
 200   const std::string& auto_login_username() const {
 201     return existing_user_controller()->public_session_auto_login_username_;
 202   }
 203
 204   int auto_login_delay() const {
 205     return existing_user_controller()->public_session_auto_login_delay_;
 206   }
 207
 208   bool is_login_in_progress() const {
 209     return existing_user_controller()->is_login_in_progress_;
 210   }
 211
 212   scoped_ptr<ExistingUserController> existing_user_controller_;
 213
 214   // |mock_login_display_| is owned by the ExistingUserController, which calls
 215   // CreateLoginDisplay() on the |mock_login_display_host_| to get it.
 216   MockLoginDisplay* mock_login_display_;
 217   scoped_ptr<MockLoginDisplayHost> mock_login_display_host_;
 218
 219   // Owned by LoginUtilsWrapper.
 220   MockLoginUtils* mock_login_utils_;
 221
 222   MockUserManager* mock_user_manager_;  // Not owned.
 223   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
 224
 225   scoped_ptr<TestingProfile> testing_profile_;
 226
 227   // Mock URLFetcher.
 228   MockURLFetcherFactory<SuccessFetcher> factory_;
 229
 230   base::Callback<void(void)> profile_prepared_cb_;
 231
 232  private:
 233   DISALLOW_COPY_AND_ASSIGN(ExistingUserControllerTest);
 234 };
 235
 236 IN_PROC_BROWSER_TEST_P(ExistingUserControllerTest, ExistingUserLogin) {
 237   // This is disabled twice: once right after signin but before checking for
 238   // auto-enrollment, and again after doing an ownership status check.
 239   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
 240       .Times(2);
 241   EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
 242       .Times(1)
 243       .WillOnce(WithArg<0>(CreateAuthenticator(kUsername, kPassword)));
 244   EXPECT_CALL(*mock_login_utils_,
 245               PrepareProfile(UserContext(kUsername, kPassword, "", kUsername),
 246                              _, _, _, _))
 247       .Times(1)
 248       .WillOnce(InvokeWithoutArgs(&profile_prepared_cb_,
 249                                   &base::Callback<void(void)>::Run));
 250   EXPECT_CALL(*mock_login_utils_,
 251               DoBrowserLaunch(testing_profile_.get(),
 252                               mock_login_display_host_.get()))
 253       .Times(1);
 254   EXPECT_CALL(*mock_login_display_, OnLoginSuccess(kUsername))
 255       .Times(1);
 256   EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
 257       .Times(1);
 258   EXPECT_CALL(*mock_login_display_, OnFadeOut())
 259       .Times(1);
 260   EXPECT_CALL(*mock_login_display_host_,
 261               StartWizardPtr(WizardController::kTermsOfServiceScreenName, NULL))
 262       .Times(0);
 263   EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
 264       .Times(AnyNumber())
 265       .WillRepeatedly(Return(false));
 266   existing_user_controller()->Login(UserContext(kUsername, kPassword, ""));
 267   content::RunAllPendingInMessageLoop();
 268 }
 269
 270 IN_PROC_BROWSER_TEST_P(ExistingUserControllerTest, AutoEnrollAfterSignIn) {
 271   EXPECT_CALL(*mock_login_display_host_,
 272               StartWizardPtr(WizardController::kEnrollmentScreenName,
 273                              _))
 274       .Times(1);
 275   EXPECT_CALL(*mock_login_display_, OnFadeOut())
 276       .Times(1);
 277   EXPECT_CALL(*mock_login_display_host_.get(), OnCompleteLogin())
 278       .Times(1);
 279   EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
 280       .Times(AnyNumber())
 281       .WillRepeatedly(Return(false));
 282   // The order of these expected calls matters: the UI if first disabled
 283   // during the login sequence, and is enabled again for the enrollment screen.
 284   Sequence uiEnabledSequence;
 285   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
 286       .Times(1)
 287       .InSequence(uiEnabledSequence);
 288   EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
 289       .Times(1)
 290       .InSequence(uiEnabledSequence);
 291   existing_user_controller()->DoAutoEnrollment();
 292   existing_user_controller()->CompleteLogin(
 293       UserContext(kUsername, kPassword, ""));
 294   content::RunAllPendingInMessageLoop();
 295 }
 296
 297 IN_PROC_BROWSER_TEST_P(ExistingUserControllerTest,
 298                        NewUserDontAutoEnrollAfterSignIn) {
 299   EXPECT_CALL(*mock_login_display_host_,
 300               StartWizardPtr(WizardController::kEnrollmentScreenName,
 301                              _))
 302       .Times(0);
 303   EXPECT_CALL(*mock_login_display_host_,
 304               StartWizardPtr(WizardController::kTermsOfServiceScreenName,
 305                              NULL))
 306       .Times(1);
 307   EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
 308       .Times(1)
 309       .WillOnce(WithArg<0>(CreateAuthenticator(kNewUsername, kPassword)));
 310   EXPECT_CALL(*mock_login_utils_,
 311               PrepareProfile(UserContext(kNewUsername,
 312                                          kPassword,
 313                                          std::string(),
 314                                          kNewUsername),
 315                              _, _, _, _))
 316       .Times(1)
 317       .WillOnce(InvokeWithoutArgs(&profile_prepared_cb_,
 318                                   &base::Callback<void(void)>::Run));
 319   EXPECT_CALL(*mock_login_display_, OnLoginSuccess(kNewUsername))
 320       .Times(1);
 321   EXPECT_CALL(*mock_login_display_, OnFadeOut())
 322       .Times(1);
 323   EXPECT_CALL(*mock_login_display_host_.get(), OnCompleteLogin())
 324       .Times(1);
 325   EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
 326       .Times(AnyNumber())
 327       .WillRepeatedly(Return(true));
 328
 329   // The order of these expected calls matters: the UI if first disabled
 330   // during the login sequence, and is enabled again after login completion.
 331   Sequence uiEnabledSequence;
 332   // This is disabled twice: once right after signin but before checking for
 333   // auto-enrollment, and again after doing an ownership status check.
 334   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
 335       .Times(2)
 336       .InSequence(uiEnabledSequence);
 337   EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
 338       .Times(1)
 339       .InSequence(uiEnabledSequence);
 340
 341   existing_user_controller()->CompleteLogin(
 342       UserContext(kNewUsername, kPassword, ""));
 343   content::RunAllPendingInMessageLoop();
 344 }
 345
 346 MATCHER_P(HasDetails, expected, "") {
 347   return expected == *content::Details<const std::string>(arg).ptr();
 348 }
 349
 350 class ExistingUserControllerPublicSessionTest
 351     : public ExistingUserControllerTest {
 352  protected:
 353   ExistingUserControllerPublicSessionTest()
 354       : public_session_user_id_(policy::GenerateDeviceLocalAccountUserId(
 355             kPublicSessionAccountId,
 356             policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION)) {
 357   }
 358
 359   virtual void SetUpOnMainThread() OVERRIDE {
 360     ExistingUserControllerTest::SetUpOnMainThread();
 361
 362     // Wait for the public session user to be created.
 363     if (!chromeos::UserManager::Get()->IsKnownUser(public_session_user_id_)) {
 364       content::WindowedNotificationObserver(
 365           chrome::NOTIFICATION_USER_LIST_CHANGED,
 366           base::Bind(&chromeos::UserManager::IsKnownUser,
 367                      base::Unretained(chromeos::UserManager::Get()),
 368                      public_session_user_id_)).Wait();
 369     }
 370
 371     // Wait for the device local account policy to be installed.
 372     policy::CloudPolicyStore* store = TestingBrowserProcess::GetGlobal()->
 373         browser_policy_connector()->GetDeviceLocalAccountPolicyService()->
 374         GetBrokerForUser(public_session_user_id_)->core()->store();
 375     if (!store->has_policy()) {
 376       policy::MockCloudPolicyStoreObserver observer;
 377
 378       base::RunLoop loop;
 379       store->AddObserver(&observer);
 380       EXPECT_CALL(observer, OnStoreLoaded(store))
 381           .Times(1)
 382           .WillOnce(InvokeWithoutArgs(&loop, &base::RunLoop::Quit));
 383       loop.Run();
 384       store->RemoveObserver(&observer);
 385     }
 386   }
 387
 388   virtual void SetUpSessionManager() OVERRIDE {
 389     InstallOwnerKey();
 390
 391     // Setup the device policy.
 392     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
 393     em::DeviceLocalAccountInfoProto* account =
 394         proto.mutable_device_local_accounts()->add_account();
 395     account->set_account_id(kPublicSessionAccountId);
 396     account->set_type(
 397         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
 398     RefreshDevicePolicy();
 399
 400     // Setup the device local account policy.
 401     policy::UserPolicyBuilder device_local_account_policy;
 402     device_local_account_policy.policy_data().set_username(
 403         kPublicSessionAccountId);
 404     device_local_account_policy.policy_data().set_policy_type(
 405         policy::dm_protocol::kChromePublicAccountPolicyType);
 406     device_local_account_policy.policy_data().set_settings_entity_id(
 407         kPublicSessionAccountId);
 408     device_local_account_policy.Build();
 409     session_manager_client()->set_device_local_account_policy(
 410         kPublicSessionAccountId,
 411         device_local_account_policy.GetBlob());
 412   }
 413
 414   virtual void SetUpLoginDisplay() OVERRIDE {
 415     EXPECT_CALL(*mock_login_display_host_.get(), CreateLoginDisplay(_))
 416         .Times(1)
 417         .WillOnce(Return(mock_login_display_));
 418     EXPECT_CALL(*mock_login_display_host_.get(), GetNativeWindow())
 419       .Times(AnyNumber())
 420       .WillRepeatedly(ReturnNull());
 421     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
 422       .Times(AnyNumber());
 423     EXPECT_CALL(*mock_login_display_, Init(_, _, _, _))
 424       .Times(AnyNumber());
 425   }
 426
 427   virtual void SetUpUserManager() OVERRIDE {
 428   }
 429
 430   void ExpectSuccessfulLogin(const std::string& username,
 431                              const std::string& password) {
 432     EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
 433         .Times(AnyNumber());
 434     EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
 435         .Times(1)
 436         .WillOnce(WithArg<0>(CreateAuthenticator(username, password)));
 437     EXPECT_CALL(*mock_login_utils_,
 438                 PrepareProfile(UserContext(username, password, "", username),
 439                                _, _, _, _))
 440         .Times(1)
 441         .WillOnce(InvokeWithoutArgs(&profile_prepared_cb_,
 442                                     &base::Callback<void(void)>::Run));
 443     EXPECT_CALL(*mock_login_utils_,
 444                 DoBrowserLaunch(testing_profile_.get(),
 445                                 mock_login_display_host_.get()))
 446         .Times(1);
 447     EXPECT_CALL(*mock_login_display_, OnLoginSuccess(username))
 448         .Times(1);
 449     EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
 450         .Times(1);
 451     EXPECT_CALL(*mock_login_display_, OnFadeOut())
 452         .Times(1);
 453     EXPECT_CALL(*mock_login_display_host_,
 454                 StartWizardPtr(WizardController::kTermsOfServiceScreenName,
 455                                NULL))
 456         .Times(0);
 457   }
 458
 459   void SetAutoLoginPolicy(const std::string& username, int delay) {
 460     // Wait until ExistingUserController has finished auto-login
 461     // configuration by observing the same settings that trigger
 462     // ConfigurePublicSessionAutoLogin.
 463
 464     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
 465
 466     // If both settings have changed we need to wait for both to
 467     // propagate, so check the new values against the old ones.
 468     scoped_refptr<content::MessageLoopRunner> runner1;
 469     scoped_ptr<CrosSettings::ObserverSubscription> subscription1;
 470     if (!proto.has_device_local_accounts() ||
 471         !proto.device_local_accounts().has_auto_login_id() ||
 472         proto.device_local_accounts().auto_login_id() != username) {
 473       runner1 = new content::MessageLoopRunner;
 474       subscription1 = chromeos::CrosSettings::Get()->AddSettingsObserver(
 475           chromeos::kAccountsPrefDeviceLocalAccountAutoLoginId,
 476           runner1->QuitClosure());
 477     }
 478     scoped_refptr<content::MessageLoopRunner> runner2;
 479     scoped_ptr<CrosSettings::ObserverSubscription> subscription2;
 480     if (!proto.has_device_local_accounts() ||
 481         !proto.device_local_accounts().has_auto_login_delay() ||
 482         proto.device_local_accounts().auto_login_delay() != delay) {
 483       runner1 = new content::MessageLoopRunner;
 484       subscription1 = chromeos::CrosSettings::Get()->AddSettingsObserver(
 485           chromeos::kAccountsPrefDeviceLocalAccountAutoLoginDelay,
 486           runner1->QuitClosure());
 487     }
 488
 489     // Update the policy.
 490     proto.mutable_device_local_accounts()->set_auto_login_id(username);
 491     proto.mutable_device_local_accounts()->set_auto_login_delay(delay);
 492     RefreshDevicePolicy();
 493
 494     // Wait for ExistingUserController to read the updated settings.
 495     if (runner1.get())
 496       runner1->Run();
 497     if (runner2.get())
 498       runner2->Run();
 499   }
 500
 501   void ConfigureAutoLogin() {
 502     existing_user_controller()->ConfigurePublicSessionAutoLogin();
 503   }
 504
 505   void FireAutoLogin() {
 506     existing_user_controller()->OnPublicSessionAutoLoginTimerFire();
 507   }
 508
 509   const std::string public_session_user_id_;
 510
 511  private:
 512   DISALLOW_COPY_AND_ASSIGN(ExistingUserControllerPublicSessionTest);
 513 };
 514
 515 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 516                        ConfigureAutoLoginUsingPolicy) {
 517   existing_user_controller()->OnSigninScreenReady();
 518   EXPECT_EQ("", auto_login_username());
 519   EXPECT_EQ(0, auto_login_delay());
 520   EXPECT_FALSE(auto_login_timer());
 521
 522   // Set the policy.
 523   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
 524   EXPECT_EQ(public_session_user_id_, auto_login_username());
 525   EXPECT_EQ(kAutoLoginLongDelay, auto_login_delay());
 526   ASSERT_TRUE(auto_login_timer());
 527   EXPECT_TRUE(auto_login_timer()->IsRunning());
 528
 529   // Unset the policy.
 530   SetAutoLoginPolicy("", 0);
 531   EXPECT_EQ("", auto_login_username());
 532   EXPECT_EQ(0, auto_login_delay());
 533   ASSERT_TRUE(auto_login_timer());
 534   EXPECT_FALSE(auto_login_timer()->IsRunning());
 535 }
 536
 537 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 538                        AutoLoginNoDelay) {
 539   // Set up mocks to check login success.
 540   ExpectSuccessfulLogin(public_session_user_id_, "");
 541   existing_user_controller()->OnSigninScreenReady();
 542
 543   // Start auto-login and wait for login tasks to complete.
 544   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginNoDelay);
 545   content::RunAllPendingInMessageLoop();
 546 }
 547
 548 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 549                        AutoLoginShortDelay) {
 550   // Set up mocks to check login success.
 551   ExpectSuccessfulLogin(public_session_user_id_, "");
 552   existing_user_controller()->OnSigninScreenReady();
 553   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginShortDelay);
 554   ASSERT_TRUE(auto_login_timer());
 555   // Don't assert that timer is running: with the short delay sometimes
 556   // the trigger happens before the assert.  We've already tested that
 557   // the timer starts when it should.
 558
 559   // Wait for the timer to fire.
 560   base::RunLoop runner;
 561   base::OneShotTimer<base::RunLoop> timer;
 562   timer.Start(FROM_HERE,
 563               base::TimeDelta::FromMilliseconds(kAutoLoginShortDelay + 1),
 564               runner.QuitClosure());
 565   runner.Run();
 566
 567   // Wait for login tasks to complete.
 568   content::RunAllPendingInMessageLoop();
 569 }
 570
 571 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 572                        LoginStopsAutoLogin) {
 573   // Set up mocks to check login success.
 574   ExpectSuccessfulLogin(kUsername, kPassword);
 575
 576   existing_user_controller()->OnSigninScreenReady();
 577   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
 578   ASSERT_TRUE(auto_login_timer());
 579
 580   // Login and check that it stopped the timer.
 581   existing_user_controller()->Login(UserContext(kUsername, kPassword, ""));
 582   EXPECT_TRUE(is_login_in_progress());
 583   ASSERT_TRUE(auto_login_timer());
 584   EXPECT_FALSE(auto_login_timer()->IsRunning());
 585
 586   // Wait for login tasks to complete.
 587   content::RunAllPendingInMessageLoop();
 588
 589   // Timer should still be stopped after login completes.
 590   ASSERT_TRUE(auto_login_timer());
 591   EXPECT_FALSE(auto_login_timer()->IsRunning());
 592 }
 593
 594 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 595                        GuestModeLoginStopsAutoLogin) {
 596   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
 597       .Times(1);
 598   EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
 599       .Times(1)
 600       .WillOnce(WithArg<0>(CreateAuthenticator(kUsername, kPassword)));
 601   EXPECT_CALL(*mock_login_utils_, CompleteOffTheRecordLogin(_))
 602       .Times(1);
 603
 604   existing_user_controller()->OnSigninScreenReady();
 605   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
 606   ASSERT_TRUE(auto_login_timer());
 607
 608   // Login and check that it stopped the timer.
 609   existing_user_controller()->LoginAsGuest();
 610   EXPECT_TRUE(is_login_in_progress());
 611   ASSERT_TRUE(auto_login_timer());
 612   EXPECT_FALSE(auto_login_timer()->IsRunning());
 613
 614   // Wait for login tasks to complete.
 615   content::RunAllPendingInMessageLoop();
 616
 617   // Timer should still be stopped after login completes.
 618   ASSERT_TRUE(auto_login_timer());
 619   EXPECT_FALSE(auto_login_timer()->IsRunning());
 620 }
 621
 622 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 623                        CompleteLoginStopsAutoLogin) {
 624   // Set up mocks to check login success.
 625   ExpectSuccessfulLogin(kUsername, kPassword);
 626   EXPECT_CALL(*mock_login_display_host_, OnCompleteLogin())
 627       .Times(1);
 628
 629   existing_user_controller()->OnSigninScreenReady();
 630   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
 631   ASSERT_TRUE(auto_login_timer());
 632
 633   // Check that login completes and stops the timer.
 634   existing_user_controller()->CompleteLogin(
 635       UserContext(kUsername, kPassword, ""));
 636   ASSERT_TRUE(auto_login_timer());
 637   EXPECT_FALSE(auto_login_timer()->IsRunning());
 638
 639   // Wait for login tasks to complete.
 640   content::RunAllPendingInMessageLoop();
 641
 642   // Timer should still be stopped after login completes.
 643   ASSERT_TRUE(auto_login_timer());
 644   EXPECT_FALSE(auto_login_timer()->IsRunning());
 645 }
 646
 647 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 648                        PublicSessionLoginStopsAutoLogin) {
 649   // Set up mocks to check login success.
 650   ExpectSuccessfulLogin(public_session_user_id_, "");
 651   existing_user_controller()->OnSigninScreenReady();
 652   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
 653   ASSERT_TRUE(auto_login_timer());
 654
 655   // Login and check that it stopped the timer.
 656   existing_user_controller()->LoginAsPublicAccount(public_session_user_id_);
 657   EXPECT_TRUE(is_login_in_progress());
 658   ASSERT_TRUE(auto_login_timer());
 659   EXPECT_FALSE(auto_login_timer()->IsRunning());
 660
 661   // Wait for login tasks to complete.
 662   content::RunAllPendingInMessageLoop();
 663
 664   // Timer should still be stopped after login completes.
 665   ASSERT_TRUE(auto_login_timer());
 666   EXPECT_FALSE(auto_login_timer()->IsRunning());
 667 }
 668
 669 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 670                        PRE_TestLoadingPublicUsersFromLocalState) {
 671   // First run propagates public accounts and stores them in Local State.
 672 }
 673
 674 IN_PROC_BROWSER_TEST_P(ExistingUserControllerPublicSessionTest,
 675                        TestLoadingPublicUsersFromLocalState) {
 676   // Second run loads list of public accounts from Local State.
 677 }
 678
 679 INSTANTIATE_TEST_CASE_P(ExistingUserControllerTestInstantiation,
 680                         ExistingUserControllerTest,
 681                         testing::Bool());
 682
 683 INSTANTIATE_TEST_CASE_P(ExistingUserControllerPublicSessionTestInstantiation,
 684                         ExistingUserControllerPublicSessionTest,
 685                         testing::Bool());
 686
 687 }  // namespace chromeos