src/chrome/browser/chromeos/login/wizard_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 "base/basictypes.h"
   6 #include "base/command_line.h"
   7 #include "base/compiler_specific.h"
   8 #include "base/path_service.h"
   9 #include "base/prefs/pref_registry_simple.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/pref_service_factory.h"
  12 #include "base/prefs/testing_pref_store.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/browser_shutdown.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  19 #include "chrome/browser/chromeos/base/locale_util.h"
  20 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
  21 #include "chrome/browser/chromeos/login/enrollment/mock_enrollment_screen.h"
  22 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  23 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
  24 #include "chrome/browser/chromeos/login/mock_authenticator.h"
  25 #include "chrome/browser/chromeos/login/mock_login_status_consumer.h"
  26 #include "chrome/browser/chromeos/login/screens/error_screen.h"
  27 #include "chrome/browser/chromeos/login/screens/mock_eula_screen.h"
  28 #include "chrome/browser/chromeos/login/screens/mock_network_screen.h"
  29 #include "chrome/browser/chromeos/login/screens/mock_update_screen.h"
  30 #include "chrome/browser/chromeos/login/screens/network_screen.h"
  31 #include "chrome/browser/chromeos/login/screens/reset_screen.h"
  32 #include "chrome/browser/chromeos/login/screens/user_image_screen.h"
  33 #include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
  34 #include "chrome/browser/chromeos/login/startup_utils.h"
  35 #include "chrome/browser/chromeos/login/test_login_utils.h"
  36 #include "chrome/browser/chromeos/login/webui_login_view.h"
  37 #include "chrome/browser/chromeos/login/wizard_controller.h"
  38 #include "chrome/browser/chromeos/login/wizard_in_process_browser_test.h"
  39 #include "chrome/browser/chromeos/policy/server_backed_device_state.h"
  40 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  41 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
  42 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  43 #include "chrome/common/chrome_paths.h"
  44 #include "chrome/common/chrome_switches.h"
  45 #include "chrome/common/pref_names.h"
  46 #include "chrome/test/base/ui_test_utils.h"
  47 #include "chromeos/audio/cras_audio_handler.h"
  48 #include "chromeos/chromeos_switches.h"
  49 #include "chromeos/chromeos_test_utils.h"
  50 #include "chromeos/dbus/dbus_thread_manager.h"
  51 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  52 #include "chromeos/dbus/fake_session_manager_client.h"
  53 #include "chromeos/network/network_state_handler.h"
  54 #include "chromeos/system/mock_statistics_provider.h"
  55 #include "chromeos/system/statistics_provider.h"
  56 #include "content/public/test/browser_test_utils.h"
  57 #include "content/public/test/test_utils.h"
  58 #include "grit/generated_resources.h"
  59 #include "net/test/spawned_test_server/spawned_test_server.h"
  60 #include "testing/gmock/include/gmock/gmock.h"
  61 #include "testing/gtest/include/gtest/gtest.h"
  62 #include "third_party/icu/source/common/unicode/locid.h"
  63 #include "ui/base/accelerators/accelerator.h"
  64 #include "ui/base/l10n/l10n_util.h"
  65
  66 using ::testing::Exactly;
  67 using ::testing::Invoke;
  68 using ::testing::Return;
  69
  70 namespace chromeos {
  71
  72 namespace {
  73 const char kUsername[] = "test_user@managedchrome.com";
  74 const char kPassword[] = "test_password";
  75
  76 class PrefStoreStub : public TestingPrefStore {
  77  public:
  78   // TestingPrefStore overrides:
  79   virtual PrefReadError GetReadError() const OVERRIDE {
  80     return PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
  81   }
  82
  83   virtual bool IsInitializationComplete() const OVERRIDE {
  84     return true;
  85   }
  86
  87  private:
  88   virtual ~PrefStoreStub() {}
  89 };
  90
  91 struct SwitchLanguageTestData {
  92   SwitchLanguageTestData() : success(false), done(false) {}
  93
  94   std::string requested_locale;
  95   std::string loaded_locale;
  96   bool success;
  97   bool done;
  98 };
  99
 100 void OnLocaleSwitched(SwitchLanguageTestData* self,
 101                       const std::string& locale,
 102                       const std::string& loaded_locale,
 103                       const bool success) {
 104   self->requested_locale = locale;
 105   self->loaded_locale = loaded_locale;
 106   self->success = success;
 107   self->done = true;
 108 }
 109
 110 void RunSwitchLanguageTest(const std::string& locale,
 111                                   const std::string& expected_locale,
 112                                   const bool expect_success) {
 113   SwitchLanguageTestData data;
 114   scoped_ptr<locale_util::SwitchLanguageCallback> callback(
 115       new locale_util::SwitchLanguageCallback(
 116           base::Bind(&OnLocaleSwitched, base::Unretained(&data))));
 117   locale_util::SwitchLanguage(locale, true, false, callback.Pass());
 118
 119   // Token writing moves control to BlockingPool and back.
 120   base::RunLoop().RunUntilIdle();
 121   content::BrowserThread::GetBlockingPool()->FlushForTesting();
 122   base::RunLoop().RunUntilIdle();
 123
 124   EXPECT_EQ(data.done, true);
 125   EXPECT_EQ(data.requested_locale, locale);
 126   EXPECT_EQ(data.loaded_locale, expected_locale);
 127   EXPECT_EQ(data.success, expect_success);
 128 }
 129
 130 void SetUpCrasAndEnableChromeVox(int volume_percent, bool mute_on) {
 131   AccessibilityManager* a11y = AccessibilityManager::Get();
 132   CrasAudioHandler* cras = CrasAudioHandler::Get();
 133
 134   // Audio output is at |volume_percent| and |mute_on|. Spoken feedback
 135   // is disabled.
 136   cras->SetOutputVolumePercent(volume_percent);
 137   cras->SetOutputMute(mute_on);
 138   a11y->EnableSpokenFeedback(false, ash::A11Y_NOTIFICATION_NONE);
 139
 140   // Spoken feedback is enabled.
 141   a11y->EnableSpokenFeedback(true, ash::A11Y_NOTIFICATION_NONE);
 142   base::RunLoop().RunUntilIdle();
 143 }
 144
 145 void QuitLoopOnAutoEnrollmentProgress(
 146     policy::AutoEnrollmentState expected_state,
 147     base::RunLoop* loop,
 148     policy::AutoEnrollmentState actual_state) {
 149   if (expected_state == actual_state)
 150     loop->Quit();
 151 }
 152
 153 void WaitForAutoEnrollmentState(policy::AutoEnrollmentState state) {
 154   base::RunLoop loop;
 155   AutoEnrollmentController* auto_enrollment_controller =
 156       LoginDisplayHostImpl::default_host()->GetAutoEnrollmentController();
 157   scoped_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
 158       progress_subscription(
 159           auto_enrollment_controller->RegisterProgressCallback(
 160               base::Bind(&QuitLoopOnAutoEnrollmentProgress, state, &loop)));
 161   loop.Run();
 162 }
 163
 164 }  // namespace
 165
 166 using ::testing::_;
 167
 168 template <class T, class H>
 169 class MockOutShowHide : public T {
 170  public:
 171   template <class P> explicit  MockOutShowHide(P p) : T(p) {}
 172   template <class P> MockOutShowHide(P p, H* actor)
 173       : T(p, actor), actor_(actor) {}
 174
 175   H* actor() const { return actor_.get(); }
 176
 177   MOCK_METHOD0(Show, void());
 178   MOCK_METHOD0(Hide, void());
 179
 180  private:
 181   scoped_ptr<H> actor_;
 182 };
 183
 184 #define MOCK(mock_var, screen_name, mocked_class, actor_class)                 \
 185   mock_var = new MockOutShowHide<mocked_class, actor_class>(                   \
 186       WizardController::default_controller(), new actor_class);                \
 187   WizardController::default_controller()->screen_name.reset(mock_var);         \
 188   EXPECT_CALL(*mock_var, Show()).Times(0);                                     \
 189   EXPECT_CALL(*mock_var, Hide()).Times(0);
 190
 191 class WizardControllerTest : public WizardInProcessBrowserTest {
 192  protected:
 193   WizardControllerTest() : WizardInProcessBrowserTest(
 194       WizardController::kTestNoScreenName) {}
 195   virtual ~WizardControllerTest() {}
 196
 197   virtual void SetUpOnMainThread() OVERRIDE {
 198     AccessibilityManager::Get()->
 199         SetProfileForTest(ProfileHelper::GetSigninProfile());
 200     WizardInProcessBrowserTest::SetUpOnMainThread();
 201   }
 202
 203   ErrorScreen* GetErrorScreen() {
 204     return static_cast<ScreenObserver*>(WizardController::default_controller())
 205         ->GetErrorScreen();
 206   }
 207
 208  private:
 209   DISALLOW_COPY_AND_ASSIGN(WizardControllerTest);
 210 };
 211
 212 IN_PROC_BROWSER_TEST_F(WizardControllerTest, SwitchLanguage) {
 213   ASSERT_TRUE(WizardController::default_controller() != NULL);
 214   WizardController::default_controller()->AdvanceToScreen(
 215       WizardController::kNetworkScreenName);
 216
 217   // Checking the default locale. Provided that the profile is cleared in SetUp.
 218   EXPECT_EQ("en-US", g_browser_process->GetApplicationLocale());
 219   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
 220   EXPECT_FALSE(base::i18n::IsRTL());
 221   const std::wstring en_str =
 222       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 223
 224   RunSwitchLanguageTest("fr", "fr", true);
 225   EXPECT_EQ("fr", g_browser_process->GetApplicationLocale());
 226   EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
 227   EXPECT_FALSE(base::i18n::IsRTL());
 228   const std::wstring fr_str =
 229       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 230
 231   EXPECT_NE(en_str, fr_str);
 232
 233   RunSwitchLanguageTest("ar", "ar", true);
 234   EXPECT_EQ("ar", g_browser_process->GetApplicationLocale());
 235   EXPECT_STREQ("ar", icu::Locale::getDefault().getLanguage());
 236   EXPECT_TRUE(base::i18n::IsRTL());
 237   const std::wstring ar_str =
 238       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 239
 240   EXPECT_NE(fr_str, ar_str);
 241 }
 242
 243 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsChangedForChromeVox) {
 244   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, true /* mute_on */);
 245
 246   // Check that output is unmuted now and at some level.
 247   CrasAudioHandler* cras = CrasAudioHandler::Get();
 248   ASSERT_FALSE(cras->IsOutputMuted());
 249   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 250             cras->GetOutputVolumePercent());
 251 }
 252
 253 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsUnchangedForChromeVox) {
 254   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, false /* mute_on */);
 255
 256   // Check that output is unmuted now and at some level.
 257   CrasAudioHandler* cras = CrasAudioHandler::Get();
 258   ASSERT_FALSE(cras->IsOutputMuted());
 259   ASSERT_EQ(75, cras->GetOutputVolumePercent());
 260 }
 261
 262 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsAdjustedForChromeVox) {
 263   SetUpCrasAndEnableChromeVox(5 /* volume_percent */, false /* mute_on */);
 264
 265   // Check that output is unmuted now and at some level.
 266   CrasAudioHandler* cras = CrasAudioHandler::Get();
 267   ASSERT_FALSE(cras->IsOutputMuted());
 268   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 269             cras->GetOutputVolumePercent());
 270 }
 271
 272 class WizardControllerFlowTest : public WizardControllerTest {
 273  protected:
 274   WizardControllerFlowTest() {}
 275   // Overriden from InProcessBrowserTest:
 276   virtual void SetUpOnMainThread() OVERRIDE {
 277     WizardControllerTest::SetUpOnMainThread();
 278
 279     // Make sure that OOBE is run as an "official" build.
 280     WizardController::default_controller()->is_official_build_ = true;
 281
 282     // Clear portal list (as it is by default in OOBE).
 283     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 284
 285     // Set up the mocks for all screens.
 286     MOCK(mock_network_screen_, network_screen_,
 287          MockNetworkScreen, MockNetworkScreenActor);
 288     MOCK(mock_update_screen_, update_screen_,
 289          MockUpdateScreen, MockUpdateScreenActor);
 290     MOCK(mock_eula_screen_, eula_screen_, MockEulaScreen, MockEulaScreenActor);
 291     MOCK(mock_enrollment_screen_, enrollment_screen_,
 292          MockEnrollmentScreen, MockEnrollmentScreenActor);
 293
 294     // Switch to the initial screen.
 295     EXPECT_EQ(NULL, WizardController::default_controller()->current_screen());
 296     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 297     WizardController::default_controller()->AdvanceToScreen(
 298         WizardController::kNetworkScreenName);
 299   }
 300
 301   void OnExit(ScreenObserver::ExitCodes exit_code) {
 302     WizardController::default_controller()->OnExit(exit_code);
 303   }
 304
 305   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
 306       mock_network_screen_;
 307   MockOutShowHide<MockUpdateScreen, MockUpdateScreenActor>* mock_update_screen_;
 308   MockOutShowHide<MockEulaScreen, MockEulaScreenActor>* mock_eula_screen_;
 309   MockOutShowHide<MockEnrollmentScreen,
 310       MockEnrollmentScreenActor>* mock_enrollment_screen_;
 311
 312  private:
 313   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 314 };
 315
 316 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
 317   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 318   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 319             WizardController::default_controller()->current_screen());
 320   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 321   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 322   OnExit(ScreenObserver::NETWORK_CONNECTED);
 323
 324   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 325             WizardController::default_controller()->current_screen());
 326   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 327   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 328   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 329   OnExit(ScreenObserver::EULA_ACCEPTED);
 330   // Let update screen smooth time process (time = 0ms).
 331   content::RunAllPendingInMessageLoop();
 332
 333   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 334             WizardController::default_controller()->current_screen());
 335   EXPECT_CALL(*mock_update_screen_, Hide()).Times(0);
 336   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 337   OnExit(ScreenObserver::UPDATE_INSTALLED);
 338
 339   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 340   EXPECT_EQ("ethernet,wifi,cellular",
 341             NetworkHandler::Get()->network_state_handler()
 342             ->GetCheckPortalListForTest());
 343 }
 344
 345 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowErrorUpdate) {
 346   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 347             WizardController::default_controller()->current_screen());
 348   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 349   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 350   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 351   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 352   OnExit(ScreenObserver::NETWORK_CONNECTED);
 353
 354   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 355             WizardController::default_controller()->current_screen());
 356   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 357   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 358   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 359   OnExit(ScreenObserver::EULA_ACCEPTED);
 360   // Let update screen smooth time process (time = 0ms).
 361   content::RunAllPendingInMessageLoop();
 362
 363   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 364             WizardController::default_controller()->current_screen());
 365   EXPECT_CALL(*mock_update_screen_, Hide()).Times(0);
 366   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 367   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(0);  // last transition
 368   OnExit(ScreenObserver::UPDATE_ERROR_UPDATING);
 369
 370   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 371 }
 372
 373 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
 374   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 375             WizardController::default_controller()->current_screen());
 376   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 377   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 378   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 379   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 380   OnExit(ScreenObserver::NETWORK_CONNECTED);
 381
 382   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 383             WizardController::default_controller()->current_screen());
 384   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 385   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 386   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 387   WizardController::default_controller()->SkipUpdateEnrollAfterEula();
 388   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 389               SetParameters(mock_enrollment_screen_,
 390                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 391                             ""))
 392       .Times(1);
 393   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 394   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(0);
 395   OnExit(ScreenObserver::EULA_ACCEPTED);
 396   content::RunAllPendingInMessageLoop();
 397
 398   EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
 399             WizardController::default_controller()->current_screen());
 400   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 401   EXPECT_EQ("ethernet,wifi,cellular",
 402             NetworkHandler::Get()->network_state_handler()
 403             ->GetCheckPortalListForTest());
 404 }
 405
 406 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowEulaDeclined) {
 407   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 408             WizardController::default_controller()->current_screen());
 409   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 410   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 411   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 412   OnExit(ScreenObserver::NETWORK_CONNECTED);
 413
 414   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 415             WizardController::default_controller()->current_screen());
 416   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 417   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 418   EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);  // last transition
 419   OnExit(ScreenObserver::EULA_BACK);
 420
 421   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 422             WizardController::default_controller()->current_screen());
 423 }
 424
 425 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 426                        ControlFlowEnrollmentCompleted) {
 427   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 428             WizardController::default_controller()->current_screen());
 429   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 430   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 431               SetParameters(mock_enrollment_screen_,
 432                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 433                             ""))
 434       .Times(1);
 435   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 436   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 437
 438   WizardController::default_controller()->AdvanceToScreen(
 439       WizardController::kEnrollmentScreenName);
 440   EnrollmentScreen* screen =
 441       WizardController::default_controller()->GetEnrollmentScreen();
 442   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 443   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 444
 445   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 446 }
 447
 448 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 449                        ControlFlowAutoEnrollmentCompleted) {
 450   WizardController::default_controller()->SkipPostLoginScreensForTesting();
 451   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 452             WizardController::default_controller()->current_screen());
 453   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 454
 455   LoginUtils::Set(new TestLoginUtils(kUsername, kPassword));
 456   MockConsumer mock_consumer;
 457
 458   // Must have a pending signin to resume after auto-enrollment:
 459   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 460   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 461   ExistingUserController::current_controller()->DoAutoEnrollment();
 462   ExistingUserController::current_controller()->set_login_status_consumer(
 463       &mock_consumer);
 464   // This calls StartWizard, destroying the current controller() and its mocks;
 465   // don't set expectations on those objects.
 466   ExistingUserController::current_controller()->CompleteLogin(
 467       UserContext(kUsername, kPassword, ""));
 468   // Run the tasks posted to complete the login:
 469   base::MessageLoop::current()->RunUntilIdle();
 470
 471   EnrollmentScreen* screen =
 472       WizardController::default_controller()->GetEnrollmentScreen();
 473   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 474   // This is the main expectation: after auto-enrollment, login is resumed.
 475   EXPECT_CALL(mock_consumer, OnLoginSuccess(_)).Times(1);
 476   OnExit(ScreenObserver::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
 477   // Prevent browser launch when the profile is prepared:
 478   browser_shutdown::SetTryingToQuit(true);
 479   // Run the tasks posted to complete the login:
 480   base::MessageLoop::current()->RunUntilIdle();
 481 }
 482
 483 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowResetScreen) {
 484   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 485             WizardController::default_controller()->current_screen());
 486
 487   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 488   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 489   ExistingUserController::current_controller()->OnStartDeviceReset();
 490
 491   ResetScreen* screen =
 492       WizardController::default_controller()->GetResetScreen();
 493   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 494
 495   // After reset screen is canceled, it returns to sign-in screen.
 496   // And this destroys WizardController.
 497   OnExit(ScreenObserver::RESET_CANCELED);
 498   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 499 }
 500
 501 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 502                        ControlFlowWrongHWIDScreenFromLogin) {
 503   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 504             WizardController::default_controller()->current_screen());
 505
 506   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 507   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 508   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 509
 510   WrongHWIDScreen* screen =
 511       WizardController::default_controller()->GetWrongHWIDScreen();
 512   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 513
 514   // After warning is skipped, user returns to sign-in screen.
 515   // And this destroys WizardController.
 516   OnExit(ScreenObserver::WRONG_HWID_WARNING_SKIPPED);
 517   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 518 }
 519
 520 class WizardControllerEnrollmentFlowTest : public WizardControllerFlowTest {
 521  protected:
 522   WizardControllerEnrollmentFlowTest() {}
 523
 524   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 525     WizardControllerFlowTest::SetUpCommandLine(command_line);
 526
 527     command_line->AppendSwitchASCII(
 528         switches::kEnterpriseEnableForcedReEnrollment,
 529         chromeos::AutoEnrollmentController::kForcedReEnrollmentAlways);
 530     command_line->AppendSwitchASCII(
 531         switches::kEnterpriseEnrollmentInitialModulus, "1");
 532     command_line->AppendSwitchASCII(
 533         switches::kEnterpriseEnrollmentModulusLimit, "2");
 534   }
 535
 536   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 537     WizardControllerFlowTest::SetUpInProcessBrowserTestFixture();
 538     system::StatisticsProvider::SetTestProvider(&statistics_provider_);
 539     EXPECT_CALL(statistics_provider_, StartLoadingMachineStatistics(_, _));
 540     EXPECT_CALL(statistics_provider_, GetMachineStatistic(_, _)).WillRepeatedly(
 541         Invoke(this, &WizardControllerEnrollmentFlowTest::GetMachineStatistic));
 542     EXPECT_CALL(statistics_provider_, GetMachineFlag(_, _)).WillRepeatedly(
 543         Return(false));
 544     EXPECT_CALL(statistics_provider_, Shutdown());
 545   }
 546
 547   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
 548     system::StatisticsProvider::SetTestProvider(NULL);
 549     WizardControllerFlowTest::TearDownInProcessBrowserTestFixture();
 550   }
 551
 552   bool GetMachineStatistic(const std::string& name, std::string* result) {
 553     if (name == system::kDiskSerialNumber) {
 554       *result = "fake-disk-serial-number";
 555       return true;
 556     } else if (name == "serial_number") {
 557       *result = "fake-machine-serial-number";
 558       return true;
 559     }
 560
 561     return false;
 562   }
 563
 564  private:
 565   system::MockStatisticsProvider statistics_provider_;
 566
 567   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnrollmentFlowTest);
 568 };
 569
 570 IN_PROC_BROWSER_TEST_F(WizardControllerEnrollmentFlowTest,
 571                        ControlFlowForcedReEnrollment) {
 572   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 573             WizardController::default_controller()->current_screen());
 574   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 575   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 576   OnExit(ScreenObserver::NETWORK_CONNECTED);
 577
 578   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 579             WizardController::default_controller()->current_screen());
 580   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 581   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 582   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 583   OnExit(ScreenObserver::EULA_ACCEPTED);
 584   // Let update screen smooth time process (time = 0ms).
 585   content::RunAllPendingInMessageLoop();
 586
 587   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 588             WizardController::default_controller()->current_screen());
 589   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 590   OnExit(ScreenObserver::UPDATE_INSTALLED);
 591
 592   // Wait for auto-enrollment controller to encounter the connection error.
 593   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 594
 595   // The error screen shows up if there's no auto-enrollment decision.
 596   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 597   EXPECT_EQ(GetErrorScreen(),
 598             WizardController::default_controller()->current_screen());
 599   base::DictionaryValue device_state;
 600   device_state.SetString(policy::kDeviceStateRestoreMode,
 601                          policy::kDeviceStateRestoreModeReEnrollmentEnforced);
 602   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
 603                                         device_state);
 604   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 605   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 606               SetParameters(mock_enrollment_screen_,
 607                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 608                             "")).Times(1);
 609   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 610
 611   // Make sure enterprise enrollment page shows up.
 612   EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
 613             WizardController::default_controller()->current_screen());
 614   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 615
 616   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 617 }
 618
 619 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
 620  protected:
 621   WizardControllerBrokenLocalStateTest()
 622       : fake_session_manager_client_(NULL) {
 623   }
 624
 625   virtual ~WizardControllerBrokenLocalStateTest() {}
 626
 627   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 628     WizardControllerTest::SetUpInProcessBrowserTestFixture();
 629
 630     FakeDBusThreadManager* fake_dbus_thread_manager =
 631         new FakeDBusThreadManager();
 632     fake_dbus_thread_manager->SetFakeClients();
 633     fake_session_manager_client_ = new FakeSessionManagerClient;
 634     fake_dbus_thread_manager->SetSessionManagerClient(
 635         scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
 636     DBusThreadManager::SetInstanceForTesting(fake_dbus_thread_manager);
 637   }
 638
 639   virtual void SetUpOnMainThread() OVERRIDE {
 640     base::PrefServiceFactory factory;
 641     factory.set_user_prefs(make_scoped_refptr(new PrefStoreStub()));
 642     local_state_ = factory.Create(new PrefRegistrySimple()).Pass();
 643     WizardController::set_local_state_for_testing(local_state_.get());
 644
 645     WizardControllerTest::SetUpOnMainThread();
 646
 647     // Make sure that OOBE is run as an "official" build.
 648     WizardController::default_controller()->is_official_build_ = true;
 649   }
 650
 651   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
 652     WizardControllerTest::TearDownInProcessBrowserTestFixture();
 653   }
 654
 655   content::WebContents* GetWebContents() {
 656     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 657         LoginDisplayHostImpl::default_host());
 658     if (!host)
 659       return NULL;
 660     WebUILoginView* webui_login_view = host->GetWebUILoginView();
 661     if (!webui_login_view)
 662       return NULL;
 663     return webui_login_view->GetWebContents();
 664   }
 665
 666   void WaitUntilJSIsReady() {
 667     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 668         LoginDisplayHostImpl::default_host());
 669     if (!host)
 670       return;
 671     chromeos::OobeUI* oobe_ui = host->GetOobeUI();
 672     if (!oobe_ui)
 673       return;
 674     base::RunLoop run_loop;
 675     const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
 676     if (!oobe_ui_ready)
 677       run_loop.Run();
 678   }
 679
 680   bool JSExecuteBooleanExpression(const std::string& expression) {
 681     bool result;
 682     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
 683         GetWebContents(),
 684         "window.domAutomationController.send(!!(" + expression + "));",
 685         &result));
 686     return result;
 687   }
 688
 689   FakeSessionManagerClient* fake_session_manager_client() const {
 690     return fake_session_manager_client_;
 691   }
 692
 693  private:
 694   scoped_ptr<PrefService> local_state_;
 695   FakeSessionManagerClient* fake_session_manager_client_;
 696
 697   DISALLOW_COPY_AND_ASSIGN(WizardControllerBrokenLocalStateTest);
 698 };
 699
 700 IN_PROC_BROWSER_TEST_F(WizardControllerBrokenLocalStateTest,
 701                        LocalStateCorrupted) {
 702   // Checks that after wizard controller initialization error screen
 703   // in the proper state is displayed.
 704   ASSERT_EQ(GetErrorScreen(),
 705             WizardController::default_controller()->current_screen());
 706   ASSERT_EQ(ErrorScreen::UI_STATE_LOCAL_STATE_ERROR,
 707             GetErrorScreen()->GetUIState());
 708
 709   WaitUntilJSIsReady();
 710
 711   // Checks visibility of the error message and powerwash button.
 712   ASSERT_FALSE(JSExecuteBooleanExpression("$('error-message').hidden"));
 713   ASSERT_TRUE(JSExecuteBooleanExpression(
 714       "$('error-message').classList.contains('ui-state-local-state-error')"));
 715   ASSERT_TRUE(JSExecuteBooleanExpression("$('progress-dots').hidden"));
 716   ASSERT_TRUE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 717
 718   // Emulates user click on the "Restart and Powerwash" button.
 719   ASSERT_EQ(0, fake_session_manager_client()->start_device_wipe_call_count());
 720   ASSERT_TRUE(content::ExecuteScript(
 721       GetWebContents(),
 722       "$('error-message-restart-and-powerwash-button').click();"));
 723   ASSERT_EQ(1, fake_session_manager_client()->start_device_wipe_call_count());
 724 }
 725
 726 class WizardControllerProxyAuthOnSigninTest : public WizardControllerTest {
 727  protected:
 728   WizardControllerProxyAuthOnSigninTest()
 729       : proxy_server_(net::SpawnedTestServer::TYPE_BASIC_AUTH_PROXY,
 730                       net::SpawnedTestServer::kLocalhost,
 731                       base::FilePath()) {
 732   }
 733   virtual ~WizardControllerProxyAuthOnSigninTest() {}
 734
 735   // Overridden from WizardControllerTest:
 736   virtual void SetUp() OVERRIDE {
 737     ASSERT_TRUE(proxy_server_.Start());
 738     WizardControllerTest::SetUp();
 739   }
 740
 741   virtual void SetUpOnMainThread() OVERRIDE {
 742     WizardControllerTest::SetUpOnMainThread();
 743     WizardController::default_controller()->AdvanceToScreen(
 744         WizardController::kNetworkScreenName);
 745   }
 746
 747   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 748     command_line->AppendSwitchASCII(::switches::kProxyServer,
 749                                     proxy_server_.host_port_pair().ToString());
 750   }
 751
 752   net::SpawnedTestServer& proxy_server() { return proxy_server_; }
 753
 754  private:
 755   net::SpawnedTestServer proxy_server_;
 756
 757   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 758 };
 759
 760 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
 761                        ProxyAuthDialogOnSigninScreen) {
 762   content::WindowedNotificationObserver auth_needed_waiter(
 763       chrome::NOTIFICATION_AUTH_NEEDED,
 764       content::NotificationService::AllSources());
 765
 766   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 767             WizardController::default_controller()->current_screen());
 768
 769   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 770   auth_needed_waiter.Wait();
 771 }
 772
 773 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
 774  protected:
 775   WizardControllerKioskFlowTest() {}
 776
 777   // Overridden from InProcessBrowserTest:
 778   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 779     base::FilePath test_data_dir;
 780     ASSERT_TRUE(chromeos::test_utils::GetTestDataPath(
 781                     "app_mode", "kiosk_manifest", &test_data_dir));
 782     command_line->AppendSwitchPath(
 783         switches::kAppOemManifestFile,
 784         test_data_dir.AppendASCII("kiosk_manifest.json"));
 785   }
 786
 787  private:
 788   DISALLOW_COPY_AND_ASSIGN(WizardControllerKioskFlowTest);
 789 };
 790
 791 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 792                        ControlFlowKioskForcedEnrollment) {
 793   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 794               SetParameters(mock_enrollment_screen_,
 795                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 796                             ""))
 797       .Times(1);
 798
 799   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 800   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 801             WizardController::default_controller()->current_screen());
 802   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 803   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 804   OnExit(ScreenObserver::NETWORK_CONNECTED);
 805
 806   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 807             WizardController::default_controller()->current_screen());
 808   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 809   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 810   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 811   OnExit(ScreenObserver::EULA_ACCEPTED);
 812   // Let update screen smooth time process (time = 0ms).
 813   content::RunAllPendingInMessageLoop();
 814
 815   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 816             WizardController::default_controller()->current_screen());
 817   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 818   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 819   OnExit(ScreenObserver::UPDATE_INSTALLED);
 820
 821   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 822
 823   // Make sure enterprise enrollment page shows up right after update screen.
 824   EnrollmentScreen* screen =
 825       WizardController::default_controller()->GetEnrollmentScreen();
 826   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 827   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 828
 829   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 830 }
 831
 832
 833 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 834                        ControlFlowEnrollmentBack) {
 835
 836   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 837               SetParameters(mock_enrollment_screen_,
 838                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 839                             ""))
 840       .Times(1);
 841
 842   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 843   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 844             WizardController::default_controller()->current_screen());
 845   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 846   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 847   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 848   OnExit(ScreenObserver::NETWORK_CONNECTED);
 849
 850   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 851             WizardController::default_controller()->current_screen());
 852   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 853   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 854   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 855   OnExit(ScreenObserver::EULA_ACCEPTED);
 856   // Let update screen smooth time process (time = 0ms).
 857   content::RunAllPendingInMessageLoop();
 858
 859   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 860             WizardController::default_controller()->current_screen());
 861   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 862   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 863   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(1);
 864   OnExit(ScreenObserver::UPDATE_INSTALLED);
 865
 866   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 867
 868   // Make sure enterprise enrollment page shows up right after update screen.
 869   EnrollmentScreen* screen =
 870       WizardController::default_controller()->GetEnrollmentScreen();
 871   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 872   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_BACK);
 873
 874   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 875             WizardController::default_controller()->current_screen());
 876   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 877 }
 878
 879 // TODO(dzhioev): Add test emaulating device with wrong HWID.
 880
 881 // TODO(nkostylev): Add test for WebUI accelerators http://crosbug.com/22571
 882
 883 COMPILE_ASSERT(ScreenObserver::EXIT_CODES_COUNT == 20,
 884                add_tests_for_new_control_flow_you_just_introduced);
 885
 886 }  // namespace chromeos