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