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 "chrome/browser/chromeos/login/wizard_controller.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/command_line.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/path_service.h"
  11 #include "base/prefs/pref_registry_simple.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/prefs/pref_service_factory.h"
  14 #include "base/prefs/testing_pref_store.h"
  15 #include "base/run_loop.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/browser_shutdown.h"
  20 #include "chrome/browser/chrome_notification_types.h"
  21 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  22 #include "chrome/browser/chromeos/base/locale_util.h"
  23 #include "chrome/browser/chromeos/geolocation/simple_geolocation_provider.h"
  24 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
  25 #include "chrome/browser/chromeos/login/enrollment/mock_auto_enrollment_check_screen.h"
  26 #include "chrome/browser/chromeos/login/enrollment/mock_enrollment_screen.h"
  27 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  28 #include "chrome/browser/chromeos/login/screens/error_screen.h"
  29 #include "chrome/browser/chromeos/login/screens/hid_detection_screen.h"
  30 #include "chrome/browser/chromeos/login/screens/mock_eula_screen.h"
  31 #include "chrome/browser/chromeos/login/screens/mock_network_screen.h"
  32 #include "chrome/browser/chromeos/login/screens/mock_update_screen.h"
  33 #include "chrome/browser/chromeos/login/screens/network_screen.h"
  34 #include "chrome/browser/chromeos/login/screens/reset_screen.h"
  35 #include "chrome/browser/chromeos/login/screens/user_image_screen.h"
  36 #include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
  37 #include "chrome/browser/chromeos/login/startup_utils.h"
  38 #include "chrome/browser/chromeos/login/test/wizard_in_process_browser_test.h"
  39 #include "chrome/browser/chromeos/login/test_login_utils.h"
  40 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
  41 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
  42 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
  43 #include "chrome/browser/chromeos/policy/server_backed_device_state.h"
  44 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  45 #include "chrome/browser/chromeos/timezone/timezone_request.h"
  46 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
  47 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  48 #include "chrome/common/chrome_paths.h"
  49 #include "chrome/common/chrome_switches.h"
  50 #include "chrome/common/pref_names.h"
  51 #include "chrome/grit/generated_resources.h"
  52 #include "chrome/test/base/ui_test_utils.h"
  53 #include "chromeos/audio/cras_audio_handler.h"
  54 #include "chromeos/chromeos_switches.h"
  55 #include "chromeos/chromeos_test_utils.h"
  56 #include "chromeos/dbus/dbus_thread_manager.h"
  57 #include "chromeos/dbus/fake_session_manager_client.h"
  58 #include "chromeos/login/auth/key.h"
  59 #include "chromeos/login/auth/mock_auth_status_consumer.h"
  60 #include "chromeos/login/auth/mock_authenticator.h"
  61 #include "chromeos/login/auth/user_context.h"
  62 #include "chromeos/network/network_state.h"
  63 #include "chromeos/network/network_state_handler.h"
  64 #include "chromeos/settings/timezone_settings.h"
  65 #include "content/public/test/browser_test_utils.h"
  66 #include "content/public/test/test_utils.h"
  67 #include "net/test/spawned_test_server/spawned_test_server.h"
  68 #include "net/url_request/test_url_fetcher_factory.h"
  69 #include "net/url_request/url_fetcher_impl.h"
  70 #include "testing/gmock/include/gmock/gmock.h"
  71 #include "testing/gtest/include/gtest/gtest.h"
  72 #include "third_party/icu/source/common/unicode/locid.h"
  73 #include "ui/base/accelerators/accelerator.h"
  74 #include "ui/base/l10n/l10n_util.h"
  75
  76 using ::testing::Exactly;
  77 using ::testing::Invoke;
  78 using ::testing::Return;
  79
  80 namespace chromeos {
  81
  82 namespace {
  83
  84 const char kUsername[] = "test_user@managedchrome.com";
  85 const char kPassword[] = "test_password";
  86
  87 const char kGeolocationResponseBody[] =
  88     "{\n"
  89     "  \"location\": {\n"
  90     "    \"lat\": 51.0,\n"
  91     "    \"lng\": -0.1\n"
  92     "  },\n"
  93     "  \"accuracy\": 1200.4\n"
  94     "}";
  95
  96 // Timezone should not match kGeolocationResponseBody to check that exactly
  97 // this value will be used.
  98 const char kTimezoneResponseBody[] =
  99     "{\n"
 100     "    \"dstOffset\" : 0.0,\n"
 101     "    \"rawOffset\" : -32400.0,\n"
 102     "    \"status\" : \"OK\",\n"
 103     "    \"timeZoneId\" : \"America/Anchorage\",\n"
 104     "    \"timeZoneName\" : \"Pacific Standard Time\"\n"
 105     "}";
 106
 107 class PrefStoreStub : public TestingPrefStore {
 108  public:
 109   // TestingPrefStore overrides:
 110   virtual PrefReadError GetReadError() const OVERRIDE {
 111     return PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
 112   }
 113
 114   virtual bool IsInitializationComplete() const OVERRIDE {
 115     return true;
 116   }
 117
 118  private:
 119   virtual ~PrefStoreStub() {}
 120 };
 121
 122 struct SwitchLanguageTestData {
 123   SwitchLanguageTestData() : success(false), done(false) {}
 124
 125   std::string requested_locale;
 126   std::string loaded_locale;
 127   bool success;
 128   bool done;
 129 };
 130
 131 void OnLocaleSwitched(SwitchLanguageTestData* self,
 132                       const std::string& locale,
 133                       const std::string& loaded_locale,
 134                       const bool success) {
 135   self->requested_locale = locale;
 136   self->loaded_locale = loaded_locale;
 137   self->success = success;
 138   self->done = true;
 139 }
 140
 141 void RunSwitchLanguageTest(const std::string& locale,
 142                                   const std::string& expected_locale,
 143                                   const bool expect_success) {
 144   SwitchLanguageTestData data;
 145   scoped_ptr<locale_util::SwitchLanguageCallback> callback(
 146       new locale_util::SwitchLanguageCallback(
 147           base::Bind(&OnLocaleSwitched, base::Unretained(&data))));
 148   locale_util::SwitchLanguage(locale, true, false, callback.Pass());
 149
 150   // Token writing moves control to BlockingPool and back.
 151   content::RunAllBlockingPoolTasksUntilIdle();
 152
 153   EXPECT_EQ(data.done, true);
 154   EXPECT_EQ(data.requested_locale, locale);
 155   EXPECT_EQ(data.loaded_locale, expected_locale);
 156   EXPECT_EQ(data.success, expect_success);
 157 }
 158
 159 void SetUpCrasAndEnableChromeVox(int volume_percent, bool mute_on) {
 160   AccessibilityManager* a11y = AccessibilityManager::Get();
 161   CrasAudioHandler* cras = CrasAudioHandler::Get();
 162
 163   // Audio output is at |volume_percent| and |mute_on|. Spoken feedback
 164   // is disabled.
 165   cras->SetOutputVolumePercent(volume_percent);
 166   cras->SetOutputMute(mute_on);
 167   a11y->EnableSpokenFeedback(false, ash::A11Y_NOTIFICATION_NONE);
 168
 169   // Spoken feedback is enabled.
 170   a11y->EnableSpokenFeedback(true, ash::A11Y_NOTIFICATION_NONE);
 171   base::RunLoop().RunUntilIdle();
 172 }
 173
 174 void QuitLoopOnAutoEnrollmentProgress(
 175     policy::AutoEnrollmentState expected_state,
 176     base::RunLoop* loop,
 177     policy::AutoEnrollmentState actual_state) {
 178   if (expected_state == actual_state)
 179     loop->Quit();
 180 }
 181
 182 void WaitForAutoEnrollmentState(policy::AutoEnrollmentState state) {
 183   base::RunLoop loop;
 184   AutoEnrollmentController* auto_enrollment_controller =
 185       LoginDisplayHostImpl::default_host()->GetAutoEnrollmentController();
 186   scoped_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
 187       progress_subscription(
 188           auto_enrollment_controller->RegisterProgressCallback(
 189               base::Bind(&QuitLoopOnAutoEnrollmentProgress, state, &loop)));
 190   loop.Run();
 191 }
 192
 193 }  // namespace
 194
 195 using ::testing::_;
 196
 197 template <class T, class H>
 198 class MockOutShowHide : public T {
 199  public:
 200   template <class P> explicit  MockOutShowHide(P p) : T(p) {}
 201   template <class P> MockOutShowHide(P p, H* actor)
 202       : T(p, actor), actor_(actor) {}
 203
 204   H* actor() const { return actor_.get(); }
 205
 206   MOCK_METHOD0(Show, void());
 207   MOCK_METHOD0(Hide, void());
 208
 209  private:
 210   scoped_ptr<H> actor_;
 211 };
 212
 213 #define MOCK(mock_var, screen_name, mocked_class, actor_class)               \
 214   mock_var = new MockOutShowHide<mocked_class, actor_class>(                 \
 215       WizardController::default_controller(), new actor_class);              \
 216   WizardController::default_controller()                                     \
 217       ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
 218   EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
 219   EXPECT_CALL(*mock_var, Hide()).Times(0);
 220
 221 class WizardControllerTest : public WizardInProcessBrowserTest {
 222  protected:
 223   WizardControllerTest() : WizardInProcessBrowserTest(
 224       WizardController::kTestNoScreenName) {}
 225   virtual ~WizardControllerTest() {}
 226
 227   virtual void SetUpOnMainThread() OVERRIDE {
 228     AccessibilityManager::Get()->
 229         SetProfileForTest(ProfileHelper::GetSigninProfile());
 230     WizardInProcessBrowserTest::SetUpOnMainThread();
 231   }
 232
 233   ErrorScreen* GetErrorScreen() {
 234     return static_cast<ScreenObserver*>(WizardController::default_controller())
 235         ->GetErrorScreen();
 236   }
 237
 238   content::WebContents* GetWebContents() {
 239     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 240         LoginDisplayHostImpl::default_host());
 241     if (!host)
 242       return NULL;
 243     WebUILoginView* webui_login_view = host->GetWebUILoginView();
 244     if (!webui_login_view)
 245       return NULL;
 246     return webui_login_view->GetWebContents();
 247   }
 248
 249   void WaitUntilJSIsReady() {
 250     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 251         LoginDisplayHostImpl::default_host());
 252     if (!host)
 253       return;
 254     chromeos::OobeUI* oobe_ui = host->GetOobeUI();
 255     if (!oobe_ui)
 256       return;
 257     base::RunLoop run_loop;
 258     const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
 259     if (!oobe_ui_ready)
 260       run_loop.Run();
 261   }
 262
 263   bool JSExecuteBooleanExpression(const std::string& expression) {
 264     bool result;
 265     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
 266         GetWebContents(),
 267         "window.domAutomationController.send(!!(" + expression + "));",
 268         &result));
 269     return result;
 270   }
 271
 272   void CheckCurrentScreen(const std::string& screen_name) {
 273     EXPECT_EQ(WizardController::default_controller()->GetScreen(screen_name),
 274               WizardController::default_controller()->current_screen());
 275   }
 276
 277  private:
 278   DISALLOW_COPY_AND_ASSIGN(WizardControllerTest);
 279 };
 280
 281 IN_PROC_BROWSER_TEST_F(WizardControllerTest, SwitchLanguage) {
 282   ASSERT_TRUE(WizardController::default_controller() != NULL);
 283   WizardController::default_controller()->AdvanceToScreen(
 284       WizardController::kNetworkScreenName);
 285
 286   // Checking the default locale. Provided that the profile is cleared in SetUp.
 287   EXPECT_EQ("en-US", g_browser_process->GetApplicationLocale());
 288   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
 289   EXPECT_FALSE(base::i18n::IsRTL());
 290   const base::string16 en_str =
 291       l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE);
 292
 293   RunSwitchLanguageTest("fr", "fr", true);
 294   EXPECT_EQ("fr", g_browser_process->GetApplicationLocale());
 295   EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
 296   EXPECT_FALSE(base::i18n::IsRTL());
 297   const base::string16 fr_str =
 298       l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE);
 299
 300   EXPECT_NE(en_str, fr_str);
 301
 302   RunSwitchLanguageTest("ar", "ar", true);
 303   EXPECT_EQ("ar", g_browser_process->GetApplicationLocale());
 304   EXPECT_STREQ("ar", icu::Locale::getDefault().getLanguage());
 305   EXPECT_TRUE(base::i18n::IsRTL());
 306   const base::string16 ar_str =
 307       l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE);
 308
 309   EXPECT_NE(fr_str, ar_str);
 310 }
 311
 312 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsChangedForChromeVox) {
 313   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, true /* mute_on */);
 314
 315   // Check that output is unmuted now and at some level.
 316   CrasAudioHandler* cras = CrasAudioHandler::Get();
 317   ASSERT_FALSE(cras->IsOutputMuted());
 318   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 319             cras->GetOutputVolumePercent());
 320 }
 321
 322 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsUnchangedForChromeVox) {
 323   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, false /* mute_on */);
 324
 325   // Check that output is unmuted now and at some level.
 326   CrasAudioHandler* cras = CrasAudioHandler::Get();
 327   ASSERT_FALSE(cras->IsOutputMuted());
 328   ASSERT_EQ(75, cras->GetOutputVolumePercent());
 329 }
 330
 331 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsAdjustedForChromeVox) {
 332   SetUpCrasAndEnableChromeVox(5 /* volume_percent */, false /* mute_on */);
 333
 334   // Check that output is unmuted now and at some level.
 335   CrasAudioHandler* cras = CrasAudioHandler::Get();
 336   ASSERT_FALSE(cras->IsOutputMuted());
 337   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 338             cras->GetOutputVolumePercent());
 339 }
 340
 341 class WizardControllerTestURLFetcherFactory
 342     : public net::TestURLFetcherFactory {
 343  public:
 344   virtual net::URLFetcher* CreateURLFetcher(
 345       int id,
 346       const GURL& url,
 347       net::URLFetcher::RequestType request_type,
 348       net::URLFetcherDelegate* d) OVERRIDE {
 349     if (StartsWithASCII(
 350             url.spec(),
 351             SimpleGeolocationProvider::DefaultGeolocationProviderURL().spec(),
 352             true)) {
 353       return new net::FakeURLFetcher(url,
 354                                      d,
 355                                      std::string(kGeolocationResponseBody),
 356                                      net::HTTP_OK,
 357                                      net::URLRequestStatus::SUCCESS);
 358     }
 359     if (StartsWithASCII(url.spec(),
 360                         chromeos::DefaultTimezoneProviderURL().spec(),
 361                         true)) {
 362       return new net::FakeURLFetcher(url,
 363                                      d,
 364                                      std::string(kTimezoneResponseBody),
 365                                      net::HTTP_OK,
 366                                      net::URLRequestStatus::SUCCESS);
 367     }
 368     return net::TestURLFetcherFactory::CreateURLFetcher(
 369         id, url, request_type, d);
 370   }
 371   virtual ~WizardControllerTestURLFetcherFactory() {}
 372 };
 373
 374 class TimeZoneTestRunner {
 375  public:
 376   void OnResolved() { loop_.Quit(); }
 377   void Run() { loop_.Run(); }
 378
 379  private:
 380   base::RunLoop loop_;
 381 };
 382
 383 class WizardControllerFlowTest : public WizardControllerTest {
 384  protected:
 385   WizardControllerFlowTest() {}
 386   // Overriden from InProcessBrowserTest:
 387   virtual void SetUpOnMainThread() OVERRIDE {
 388     WizardControllerTest::SetUpOnMainThread();
 389
 390     // Make sure that OOBE is run as an "official" build.
 391     WizardController::default_controller()->is_official_build_ = true;
 392
 393     // Clear portal list (as it is by default in OOBE).
 394     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 395
 396     // Set up the mocks for all screens.
 397     MOCK(mock_network_screen_,
 398          kNetworkScreenName,
 399          MockNetworkScreen,
 400          MockNetworkScreenActor);
 401     MOCK(mock_update_screen_,
 402          kUpdateScreenName,
 403          MockUpdateScreen,
 404          MockUpdateScreenActor);
 405     MOCK(mock_eula_screen_,
 406          kEulaScreenName,
 407          MockEulaScreen,
 408          MockEulaScreenActor);
 409     MOCK(mock_enrollment_screen_,
 410          kEnrollmentScreenName,
 411          MockEnrollmentScreen,
 412          MockEnrollmentScreenActor);
 413     MOCK(mock_auto_enrollment_check_screen_,
 414          kAutoEnrollmentCheckScreenName,
 415          MockAutoEnrollmentCheckScreen,
 416          MockAutoEnrollmentCheckScreenActor);
 417
 418     // Switch to the initial screen.
 419     EXPECT_EQ(NULL, WizardController::default_controller()->current_screen());
 420     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 421     WizardController::default_controller()->AdvanceToScreen(
 422         WizardController::kNetworkScreenName);
 423   }
 424
 425   virtual void TearDown() {
 426     if (fallback_fetcher_factory_) {
 427       fetcher_factory_.reset();
 428       net::URLFetcherImpl::set_factory(fallback_fetcher_factory_.get());
 429       fallback_fetcher_factory_.reset();
 430     }
 431   }
 432
 433   void InitTimezoneResolver() {
 434     fallback_fetcher_factory_.reset(new WizardControllerTestURLFetcherFactory);
 435     net::URLFetcherImpl::set_factory(NULL);
 436     fetcher_factory_.reset(
 437         new net::FakeURLFetcherFactory(fallback_fetcher_factory_.get()));
 438
 439     network_portal_detector_ = new NetworkPortalDetectorTestImpl();
 440     NetworkPortalDetector::InitializeForTesting(network_portal_detector_);
 441
 442     NetworkPortalDetector::CaptivePortalState online_state;
 443     online_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
 444     online_state.response_code = 204;
 445
 446     // Default detworks happens to be usually "eth1" in tests.
 447     const NetworkState* default_network =
 448         NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 449
 450     network_portal_detector_->SetDefaultNetworkForTesting(
 451         default_network->guid());
 452     network_portal_detector_->SetDetectionResultsForTesting(
 453         default_network->guid(),
 454         online_state);
 455   }
 456
 457   void OnExit(ScreenObserver::ExitCodes exit_code) {
 458     WizardController::default_controller()->OnExit(exit_code);
 459   }
 460
 461   chromeos::SimpleGeolocationProvider* GetGeolocationProvider() {
 462     return WizardController::default_controller()->geolocation_provider_.get();
 463   }
 464
 465   void WaitUntilTimezoneResolved() {
 466     scoped_ptr<TimeZoneTestRunner> runner(new TimeZoneTestRunner);
 467     if (!WizardController::default_controller()
 468              ->SetOnTimeZoneResolvedForTesting(
 469                  base::Bind(&TimeZoneTestRunner::OnResolved,
 470                             base::Unretained(runner.get()))))
 471       return;
 472
 473     runner->Run();
 474   }
 475
 476   void ResetAutoEnrollmentCheckScreen() {
 477     WizardController::default_controller()->screens_.erase(
 478         WizardController::kAutoEnrollmentCheckScreenName);
 479   }
 480
 481   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
 482       mock_network_screen_;
 483   MockOutShowHide<MockUpdateScreen, MockUpdateScreenActor>* mock_update_screen_;
 484   MockOutShowHide<MockEulaScreen, MockEulaScreenActor>* mock_eula_screen_;
 485   MockOutShowHide<MockEnrollmentScreen,
 486       MockEnrollmentScreenActor>* mock_enrollment_screen_;
 487   MockOutShowHide<MockAutoEnrollmentCheckScreen,
 488       MockAutoEnrollmentCheckScreenActor>* mock_auto_enrollment_check_screen_;
 489
 490  private:
 491   NetworkPortalDetectorTestImpl* network_portal_detector_;
 492
 493   // Use a test factory as a fallback so we don't have to deal with other
 494   // requests.
 495   scoped_ptr<WizardControllerTestURLFetcherFactory> fallback_fetcher_factory_;
 496   scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
 497
 498   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 499 };
 500
 501 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
 502   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 503   CheckCurrentScreen(WizardController::kNetworkScreenName);
 504
 505   WaitUntilJSIsReady();
 506
 507   // Check visibility of the header bar.
 508   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 509
 510   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 511   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 512   OnExit(ScreenObserver::NETWORK_CONNECTED);
 513
 514   CheckCurrentScreen(WizardController::kEulaScreenName);
 515
 516   // Header bar should still be visible.
 517   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 518
 519   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 520   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 521   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 522   // Enable TimeZone resolve
 523   InitTimezoneResolver();
 524   OnExit(ScreenObserver::EULA_ACCEPTED);
 525   EXPECT_TRUE(GetGeolocationProvider());
 526   // Let update screen smooth time process (time = 0ms).
 527   content::RunAllPendingInMessageLoop();
 528
 529   CheckCurrentScreen(WizardController::kUpdateScreenName);
 530   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 531   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 532   OnExit(ScreenObserver::UPDATE_INSTALLED);
 533
 534   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
 535   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
 536   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 537   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 538
 539   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 540   EXPECT_EQ("ethernet,wifi,cellular",
 541             NetworkHandler::Get()->network_state_handler()
 542             ->GetCheckPortalListForTest());
 543
 544   WaitUntilTimezoneResolved();
 545   EXPECT_EQ("America/Anchorage",
 546             base::UTF16ToUTF8(chromeos::system::TimezoneSettings::GetInstance()
 547                                   ->GetCurrentTimezoneID()));
 548 }
 549
 550 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowErrorUpdate) {
 551   CheckCurrentScreen(WizardController::kNetworkScreenName);
 552   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 553   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 554   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 555   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 556   OnExit(ScreenObserver::NETWORK_CONNECTED);
 557
 558   CheckCurrentScreen(WizardController::kEulaScreenName);
 559   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 560   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 561   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 562   OnExit(ScreenObserver::EULA_ACCEPTED);
 563   // Let update screen smooth time process (time = 0ms).
 564   content::RunAllPendingInMessageLoop();
 565
 566   CheckCurrentScreen(WizardController::kUpdateScreenName);
 567   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 568   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 569   OnExit(ScreenObserver::UPDATE_ERROR_UPDATING);
 570
 571   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
 572   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
 573   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 574   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 575
 576   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 577 }
 578
 579 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
 580   CheckCurrentScreen(WizardController::kNetworkScreenName);
 581   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 582   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 583   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 584   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 585   OnExit(ScreenObserver::NETWORK_CONNECTED);
 586
 587   CheckCurrentScreen(WizardController::kEulaScreenName);
 588   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 589   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 590   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 591   WizardController::default_controller()->SkipUpdateEnrollAfterEula();
 592   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 593               SetParameters(mock_enrollment_screen_,
 594                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 595                             ""))
 596       .Times(1);
 597   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 598   OnExit(ScreenObserver::EULA_ACCEPTED);
 599   content::RunAllPendingInMessageLoop();
 600
 601   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
 602   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
 603   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 604   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(0);
 605   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 606   content::RunAllPendingInMessageLoop();
 607
 608   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 609   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 610   EXPECT_EQ("ethernet,wifi,cellular",
 611             NetworkHandler::Get()->network_state_handler()
 612             ->GetCheckPortalListForTest());
 613 }
 614
 615 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowEulaDeclined) {
 616   CheckCurrentScreen(WizardController::kNetworkScreenName);
 617   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 618   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 619   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 620   OnExit(ScreenObserver::NETWORK_CONNECTED);
 621
 622   CheckCurrentScreen(WizardController::kEulaScreenName);
 623   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 624   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 625   EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);  // last transition
 626   OnExit(ScreenObserver::EULA_BACK);
 627
 628   CheckCurrentScreen(WizardController::kNetworkScreenName);
 629 }
 630
 631 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 632                        ControlFlowEnrollmentCompleted) {
 633   CheckCurrentScreen(WizardController::kNetworkScreenName);
 634   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 635   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 636               SetParameters(mock_enrollment_screen_,
 637                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 638                             ""))
 639       .Times(1);
 640   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 641   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 642
 643   WizardController::default_controller()->AdvanceToScreen(
 644       WizardController::kEnrollmentScreenName);
 645   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 646   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 647
 648   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 649 }
 650
 651 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 652                        ControlFlowAutoEnrollmentCompleted) {
 653   WizardController::default_controller()->SkipPostLoginScreensForTesting();
 654   CheckCurrentScreen(WizardController::kNetworkScreenName);
 655   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 656
 657   UserContext user_context(kUsername);
 658   user_context.SetKey(Key(kPassword));
 659   user_context.SetUserIDHash(user_context.GetUserID());
 660   LoginUtils::Set(new TestLoginUtils(user_context));
 661   MockAuthStatusConsumer mock_consumer;
 662
 663   // Must have a pending signin to resume after auto-enrollment:
 664   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 665   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 666   ExistingUserController::current_controller()->DoAutoEnrollment();
 667   ExistingUserController::current_controller()->set_login_status_consumer(
 668       &mock_consumer);
 669   // This calls StartWizard, destroying the current controller() and its mocks;
 670   // don't set expectations on those objects.
 671   ExistingUserController::current_controller()->CompleteLogin(user_context);
 672   // Run the tasks posted to complete the login:
 673   base::MessageLoop::current()->RunUntilIdle();
 674
 675   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 676   // This is the main expectation: after auto-enrollment, login is resumed.
 677   EXPECT_CALL(mock_consumer, OnAuthSuccess(_)).Times(1);
 678   OnExit(ScreenObserver::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
 679   // Prevent browser launch when the profile is prepared:
 680   browser_shutdown::SetTryingToQuit(true);
 681   // Run the tasks posted to complete the login:
 682   base::MessageLoop::current()->RunUntilIdle();
 683 }
 684
 685 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 686                        ControlFlowWrongHWIDScreenFromLogin) {
 687   CheckCurrentScreen(WizardController::kNetworkScreenName);
 688
 689   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 690   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 691   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 692
 693   CheckCurrentScreen(WizardController::kWrongHWIDScreenName);
 694
 695   // After warning is skipped, user returns to sign-in screen.
 696   // And this destroys WizardController.
 697   OnExit(ScreenObserver::WRONG_HWID_WARNING_SKIPPED);
 698   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 699 }
 700
 701 class WizardControllerEnrollmentFlowTest : public WizardControllerFlowTest {
 702  protected:
 703   WizardControllerEnrollmentFlowTest() {}
 704
 705   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 706     WizardControllerFlowTest::SetUpCommandLine(command_line);
 707
 708     command_line->AppendSwitchASCII(
 709         switches::kEnterpriseEnableForcedReEnrollment,
 710         chromeos::AutoEnrollmentController::kForcedReEnrollmentAlways);
 711     command_line->AppendSwitchASCII(
 712         switches::kEnterpriseEnrollmentInitialModulus, "1");
 713     command_line->AppendSwitchASCII(
 714         switches::kEnterpriseEnrollmentModulusLimit, "2");
 715   }
 716
 717  private:
 718   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnrollmentFlowTest);
 719 };
 720
 721 IN_PROC_BROWSER_TEST_F(WizardControllerEnrollmentFlowTest,
 722                        ControlFlowForcedReEnrollment) {
 723   CheckCurrentScreen(WizardController::kNetworkScreenName);
 724   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 725   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 726   OnExit(ScreenObserver::NETWORK_CONNECTED);
 727
 728   CheckCurrentScreen(WizardController::kEulaScreenName);
 729   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 730   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 731   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 732   OnExit(ScreenObserver::EULA_ACCEPTED);
 733   // Let update screen smooth time process (time = 0ms).
 734   content::RunAllPendingInMessageLoop();
 735
 736   CheckCurrentScreen(WizardController::kUpdateScreenName);
 737   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 738   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 739   OnExit(ScreenObserver::UPDATE_INSTALLED);
 740
 741   AutoEnrollmentCheckScreen* screen =
 742       AutoEnrollmentCheckScreen::Get(WizardController::default_controller());
 743   EXPECT_EQ(screen,
 744             WizardController::default_controller()->current_screen());
 745   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
 746   screen->Start();
 747   // Wait for auto-enrollment controller to encounter the connection error.
 748   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 749
 750   // The error screen shows up if there's no auto-enrollment decision.
 751   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 752   EXPECT_EQ(GetErrorScreen(),
 753             WizardController::default_controller()->current_screen());
 754   base::DictionaryValue device_state;
 755   device_state.SetString(policy::kDeviceStateRestoreMode,
 756                          policy::kDeviceStateRestoreModeReEnrollmentEnforced);
 757   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
 758                                         device_state);
 759   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 760   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 761               SetParameters(mock_enrollment_screen_,
 762                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 763                             "")).Times(1);
 764   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 765
 766   ResetAutoEnrollmentCheckScreen();
 767
 768   // Make sure enterprise enrollment page shows up.
 769   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 770   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 771
 772   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 773 }
 774
 775 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
 776  protected:
 777   WizardControllerBrokenLocalStateTest()
 778       : fake_session_manager_client_(NULL) {
 779   }
 780
 781   virtual ~WizardControllerBrokenLocalStateTest() {}
 782
 783   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 784     WizardControllerTest::SetUpInProcessBrowserTestFixture();
 785
 786     fake_session_manager_client_ = new FakeSessionManagerClient;
 787     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
 788         scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
 789   }
 790
 791   virtual void SetUpOnMainThread() OVERRIDE {
 792     base::PrefServiceFactory factory;
 793     factory.set_user_prefs(make_scoped_refptr(new PrefStoreStub()));
 794     local_state_ = factory.Create(new PrefRegistrySimple()).Pass();
 795     WizardController::set_local_state_for_testing(local_state_.get());
 796
 797     WizardControllerTest::SetUpOnMainThread();
 798
 799     // Make sure that OOBE is run as an "official" build.
 800     WizardController::default_controller()->is_official_build_ = true;
 801   }
 802
 803   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
 804     WizardControllerTest::TearDownInProcessBrowserTestFixture();
 805   }
 806
 807
 808   FakeSessionManagerClient* fake_session_manager_client() const {
 809     return fake_session_manager_client_;
 810   }
 811
 812  private:
 813   scoped_ptr<PrefService> local_state_;
 814   FakeSessionManagerClient* fake_session_manager_client_;
 815
 816   DISALLOW_COPY_AND_ASSIGN(WizardControllerBrokenLocalStateTest);
 817 };
 818
 819 IN_PROC_BROWSER_TEST_F(WizardControllerBrokenLocalStateTest,
 820                        LocalStateCorrupted) {
 821   // Checks that after wizard controller initialization error screen
 822   // in the proper state is displayed.
 823   ASSERT_EQ(GetErrorScreen(),
 824             WizardController::default_controller()->current_screen());
 825   ASSERT_EQ(ErrorScreen::UI_STATE_LOCAL_STATE_ERROR,
 826             GetErrorScreen()->GetUIState());
 827
 828   WaitUntilJSIsReady();
 829
 830   // Checks visibility of the error message and powerwash button.
 831   ASSERT_FALSE(JSExecuteBooleanExpression("$('error-message').hidden"));
 832   ASSERT_TRUE(JSExecuteBooleanExpression(
 833       "$('error-message').classList.contains('ui-state-local-state-error')"));
 834   ASSERT_TRUE(JSExecuteBooleanExpression("$('progress-dots').hidden"));
 835   ASSERT_TRUE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 836
 837   // Emulates user click on the "Restart and Powerwash" button.
 838   ASSERT_EQ(0, fake_session_manager_client()->start_device_wipe_call_count());
 839   ASSERT_TRUE(content::ExecuteScript(
 840       GetWebContents(),
 841       "$('error-message-restart-and-powerwash-button').click();"));
 842   ASSERT_EQ(1, fake_session_manager_client()->start_device_wipe_call_count());
 843 }
 844
 845 class WizardControllerProxyAuthOnSigninTest : public WizardControllerTest {
 846  protected:
 847   WizardControllerProxyAuthOnSigninTest()
 848       : proxy_server_(net::SpawnedTestServer::TYPE_BASIC_AUTH_PROXY,
 849                       net::SpawnedTestServer::kLocalhost,
 850                       base::FilePath()) {
 851   }
 852   virtual ~WizardControllerProxyAuthOnSigninTest() {}
 853
 854   // Overridden from WizardControllerTest:
 855   virtual void SetUp() OVERRIDE {
 856     ASSERT_TRUE(proxy_server_.Start());
 857     WizardControllerTest::SetUp();
 858   }
 859
 860   virtual void SetUpOnMainThread() OVERRIDE {
 861     WizardControllerTest::SetUpOnMainThread();
 862     WizardController::default_controller()->AdvanceToScreen(
 863         WizardController::kNetworkScreenName);
 864   }
 865
 866   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 867     command_line->AppendSwitchASCII(::switches::kProxyServer,
 868                                     proxy_server_.host_port_pair().ToString());
 869   }
 870
 871   net::SpawnedTestServer& proxy_server() { return proxy_server_; }
 872
 873  private:
 874   net::SpawnedTestServer proxy_server_;
 875
 876   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 877 };
 878
 879 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
 880                        ProxyAuthDialogOnSigninScreen) {
 881   content::WindowedNotificationObserver auth_needed_waiter(
 882       chrome::NOTIFICATION_AUTH_NEEDED,
 883       content::NotificationService::AllSources());
 884
 885   CheckCurrentScreen(WizardController::kNetworkScreenName);
 886
 887   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 888   auth_needed_waiter.Wait();
 889 }
 890
 891 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
 892  protected:
 893   WizardControllerKioskFlowTest() {}
 894
 895   // Overridden from InProcessBrowserTest:
 896   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 897     base::FilePath test_data_dir;
 898     ASSERT_TRUE(chromeos::test_utils::GetTestDataPath(
 899                     "app_mode", "kiosk_manifest", &test_data_dir));
 900     command_line->AppendSwitchPath(
 901         switches::kAppOemManifestFile,
 902         test_data_dir.AppendASCII("kiosk_manifest.json"));
 903   }
 904
 905  private:
 906   DISALLOW_COPY_AND_ASSIGN(WizardControllerKioskFlowTest);
 907 };
 908
 909 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 910                        ControlFlowKioskForcedEnrollment) {
 911   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 912               SetParameters(mock_enrollment_screen_,
 913                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 914                             ""))
 915       .Times(1);
 916
 917   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 918   CheckCurrentScreen(WizardController::kNetworkScreenName);
 919   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 920   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 921   OnExit(ScreenObserver::NETWORK_CONNECTED);
 922
 923   CheckCurrentScreen(WizardController::kEulaScreenName);
 924   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 925   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 926   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 927   OnExit(ScreenObserver::EULA_ACCEPTED);
 928   // Let update screen smooth time process (time = 0ms).
 929   content::RunAllPendingInMessageLoop();
 930
 931   CheckCurrentScreen(WizardController::kUpdateScreenName);
 932   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 933   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 934   OnExit(ScreenObserver::UPDATE_INSTALLED);
 935
 936   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
 937   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
 938   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 939   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 940
 941
 942   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 943
 944   // Make sure enterprise enrollment page shows up right after update screen.
 945   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 946   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 947
 948   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 949 }
 950
 951
 952 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 953                        ControlFlowEnrollmentBack) {
 954   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 955               SetParameters(mock_enrollment_screen_,
 956                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 957                             ""))
 958       .Times(1);
 959
 960   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 961   CheckCurrentScreen(WizardController::kNetworkScreenName);
 962   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 963   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 964   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 965   OnExit(ScreenObserver::NETWORK_CONNECTED);
 966
 967   CheckCurrentScreen(WizardController::kEulaScreenName);
 968   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 969   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 970   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 971   OnExit(ScreenObserver::EULA_ACCEPTED);
 972   // Let update screen smooth time process (time = 0ms).
 973   content::RunAllPendingInMessageLoop();
 974
 975   CheckCurrentScreen(WizardController::kUpdateScreenName);
 976   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 977   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
 978   OnExit(ScreenObserver::UPDATE_INSTALLED);
 979
 980   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
 981   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
 982   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 983   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(1);
 984   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 985
 986   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 987
 988   // Make sure enterprise enrollment page shows up right after update screen.
 989   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 990   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_BACK);
 991
 992   CheckCurrentScreen(WizardController::kNetworkScreenName);
 993   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 994 }
 995
 996 class WizardControllerOobeResumeTest : public WizardControllerTest {
 997  protected:
 998   WizardControllerOobeResumeTest() {}
 999   // Overriden from InProcessBrowserTest:
1000   virtual void SetUpOnMainThread() OVERRIDE {
1001     WizardControllerTest::SetUpOnMainThread();
1002
1003     // Make sure that OOBE is run as an "official" build.
1004     WizardController::default_controller()->is_official_build_ = true;
1005
1006     // Clear portal list (as it is by default in OOBE).
1007     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
1008
1009     // Set up the mocks for all screens.
1010     MOCK(mock_network_screen_,
1011          kNetworkScreenName,
1012          MockNetworkScreen,
1013          MockNetworkScreenActor);
1014     MOCK(mock_enrollment_screen_,
1015          kEnrollmentScreenName,
1016          MockEnrollmentScreen,
1017          MockEnrollmentScreenActor);
1018   }
1019
1020   void OnExit(ScreenObserver::ExitCodes exit_code) {
1021     WizardController::default_controller()->OnExit(exit_code);
1022   }
1023
1024   std::string GetFirstScreenName() {
1025     return WizardController::default_controller()->first_screen_name();
1026   }
1027
1028   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
1029       mock_network_screen_;
1030   MockOutShowHide<MockEnrollmentScreen,
1031       MockEnrollmentScreenActor>* mock_enrollment_screen_;
1032
1033  private:
1034   DISALLOW_COPY_AND_ASSIGN(WizardControllerOobeResumeTest);
1035 };
1036
1037 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
1038                        PRE_ControlFlowResumeInterruptedOobe) {
1039   // Switch to the initial screen.
1040   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
1041   WizardController::default_controller()->AdvanceToScreen(
1042       WizardController::kNetworkScreenName);
1043   CheckCurrentScreen(WizardController::kNetworkScreenName);
1044   EXPECT_CALL(*mock_enrollment_screen_->actor(),
1045               SetParameters(mock_enrollment_screen_,
1046                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
1047                             "")).Times(1);
1048   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
1049   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
1050
1051   WizardController::default_controller()->AdvanceToScreen(
1052       WizardController::kEnrollmentScreenName);
1053   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
1054 }
1055
1056 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
1057                        ControlFlowResumeInterruptedOobe) {
1058   EXPECT_EQ(WizardController::kEnrollmentScreenName, GetFirstScreenName());
1059 }
1060
1061 // TODO(dzhioev): Add test emaulating device with wrong HWID.
1062
1063 // TODO(nkostylev): Add test for WebUI accelerators http://crosbug.com/22571
1064
1065 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
1066 // UI and logic is ready. http://crbug.com/127016
1067
1068 // TODO(dzhioev): Add tests for controller/host pairing flow.
1069 // http://crbug.com/375191
1070
1071 COMPILE_ASSERT(ScreenObserver::EXIT_CODES_COUNT == 23,
1072                add_tests_for_new_control_flow_you_just_introduced);
1073
1074 }  // namespace chromeos