Home | History | Annotate | Download | only in login 
      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 (at) 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
   1075