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