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
76using ::testing::Exactly;
77using ::testing::Invoke;
78using ::testing::Return;
79
80namespace chromeos {
81
82namespace {
83
84const char kUsername[] = "test_user@managedchrome.com";
85const char kPassword[] = "test_password";
86
87const 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.
98const 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
107class 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
122struct 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
131void 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
141void 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
159void 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
174void 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
182void 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
195using ::testing::_;
196
197template <class T, class H>
198class 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
221class 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
281IN_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
312IN_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
322IN_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
331IN_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
341class 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
374class TimeZoneTestRunner {
375 public:
376  void OnResolved() { loop_.Quit(); }
377  void Run() { loop_.Run(); }
378
379 private:
380  base::RunLoop loop_;
381};
382
383class 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
501IN_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
550IN_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
579IN_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
615IN_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
631IN_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
651IN_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
685IN_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
701class 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
721IN_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
775class 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
819IN_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
845class 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
879IN_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
891class 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
909IN_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
952IN_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
996class 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
1037IN_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
1056IN_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
1071COMPILE_ASSERT(ScreenObserver::EXIT_CODES_COUNT == 23,
1072               add_tests_for_new_control_flow_you_just_introduced);
1073
1074}  // namespace chromeos
1075