ScreenObserver is renamed to BaseScreenDelegate.

chrome/browser/chromeos/login/wizard_controller_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/path_service.h"
@@ skipping 222 matching lines @@
       WizardController::kTestNoScreenName) {}
   virtual ~WizardControllerTest() {}
 
   virtual void SetUpOnMainThread() override {
     AccessibilityManager::Get()->
         SetProfileForTest(ProfileHelper::GetSigninProfile());
     WizardInProcessBrowserTest::SetUpOnMainThread();
   }
 
   ErrorScreen* GetErrorScreen() {
-    return static_cast<ScreenObserver*>(WizardController::default_controller())
-        ->GetErrorScreen();
+    return static_cast<BaseScreenDelegate*>(
+               WizardController::default_controller())->GetErrorScreen();
   }
 
   content::WebContents* GetWebContents() {
     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
         LoginDisplayHostImpl::default_host());
     if (!host)
       return NULL;
     WebUILoginView* webui_login_view = host->GetWebUILoginView();
     if (!webui_login_view)
       return NULL;
@@ skipping 213 matching lines @@
     const NetworkState* default_network =
         NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
 
     network_portal_detector_->SetDefaultNetworkForTesting(
         default_network->guid());
     network_portal_detector_->SetDetectionResultsForTesting(
         default_network->guid(),
         online_state);
   }
 
-  void OnExit(ScreenObserver::ExitCodes exit_code) {
+  void OnExit(BaseScreenDelegate::ExitCodes exit_code) {
     WizardController::default_controller()->OnExit(exit_code);
   }
 
   chromeos::SimpleGeolocationProvider* GetGeolocationProvider() {
     return WizardController::default_controller()->geolocation_provider_.get();
   }
 
   void WaitUntilTimezoneResolved() {
     scoped_ptr<TimeZoneTestRunner> runner(new TimeZoneTestRunner);
     if (!WizardController::default_controller()
@@ skipping 35 matching lines @@
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   WaitUntilJSIsReady();
 
   // Check visibility of the header bar.
   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
 
   // Header bar should still be visible.
   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
   // Enable TimeZone resolve
   InitTimezoneResolver();
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
   EXPECT_TRUE(GetGeolocationProvider());
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   EXPECT_EQ("ethernet,wifi,cellular",
             NetworkHandler::Get()->network_state_handler()
             ->GetCheckPortalListForTest());
 
   WaitUntilTimezoneResolved();
   EXPECT_EQ("America/Anchorage",
             base::UTF16ToUTF8(chromeos::system::TimezoneSettings::GetInstance()
                                   ->GetCurrentTimezoneID()));
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowErrorUpdate) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_ERROR_UPDATING);
+  OnExit(BaseScreenDelegate::UPDATE_ERROR_UPDATING);
 
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
   WizardController::default_controller()->SkipUpdateEnrollAfterEula();
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
                             ""))
       .Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(0);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
   EXPECT_EQ("ethernet,wifi,cellular",
             NetworkHandler::Get()->network_state_handler()
             ->GetCheckPortalListForTest());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowEulaDeclined) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);  // last transition
-  OnExit(ScreenObserver::EULA_BACK);
+  OnExit(BaseScreenDelegate::EULA_BACK);
 
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowEnrollmentCompleted) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
                             ""))
       .Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 
   WizardController::default_controller()->AdvanceToScreen(
       WizardController::kEnrollmentScreenName);
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
-  OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowAutoEnrollmentCompleted) {
   WizardController::default_controller()->SkipPostLoginScreensForTesting();
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 
@@ skipping 11 matching lines @@
       &mock_consumer);
   // This calls StartWizard, destroying the current controller() and its mocks;
   // don't set expectations on those objects.
   ExistingUserController::current_controller()->CompleteLogin(user_context);
   // Run the tasks posted to complete the login:
   base::MessageLoop::current()->RunUntilIdle();
 
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   // This is the main expectation: after auto-enrollment, login is resumed.
   EXPECT_CALL(mock_consumer, OnAuthSuccess(_)).Times(1);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
   // Prevent browser launch when the profile is prepared:
   browser_shutdown::SetTryingToQuit(true);
   // Run the tasks posted to complete the login:
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowWrongHWIDScreenFromLogin) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 
   CheckCurrentScreen(WizardController::kWrongHWIDScreenName);
 
   // After warning is skipped, user returns to sign-in screen.
   // And this destroys WizardController.
-  OnExit(ScreenObserver::WRONG_HWID_WARNING_SKIPPED);
+  OnExit(BaseScreenDelegate::WRONG_HWID_WARNING_SKIPPED);
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 class WizardControllerDeviceStateTest : public WizardControllerFlowTest {
  protected:
   WizardControllerDeviceStateTest()
       : install_attributes_(std::string(),
                             std::string(),
                             std::string(),
                             policy::DEVICE_MODE_NOT_SET) {
@@ skipping 20 matching lines @@
   policy::ScopedStubEnterpriseInstallAttributes install_attributes_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerDeviceStateTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowForcedReEnrollment) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   AutoEnrollmentCheckScreen* screen =
       AutoEnrollmentCheckScreen::Get(WizardController::default_controller());
   EXPECT_EQ(screen,
             WizardController::default_controller()->current_screen());
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   screen->Start();
 
   // Wait for auto-enrollment controller to encounter the connection error.
   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 
   // The error screen shows up if there's no auto-enrollment decision.
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
   EXPECT_EQ(GetErrorScreen(),
             WizardController::default_controller()->current_screen());
   base::DictionaryValue device_state;
   device_state.SetString(policy::kDeviceStateRestoreMode,
                          policy::kDeviceStateRestoreModeReEnrollmentEnforced);
   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
                                         device_state);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
                             "")).Times(1);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   ResetAutoEnrollmentCheckScreen();
 
   // Make sure enterprise enrollment page shows up.
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
-  OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowNoForcedReEnrollmentOnFirstBoot) {
   fake_statistics_provider_.ClearMachineStatistic(system::kActivateDateKey);
   EXPECT_NE(policy::AUTO_ENROLLMENT_STATE_NO_ENROLLMENT,
             LoginDisplayHostImpl::default_host()
                 ->GetAutoEnrollmentController()
                 ->state());
 
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   AutoEnrollmentCheckScreen* screen =
       AutoEnrollmentCheckScreen::Get(WizardController::default_controller());
   EXPECT_EQ(screen,
             WizardController::default_controller()->current_screen());
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   screen->Start();
   EXPECT_EQ(policy::AUTO_ENROLLMENT_STATE_NO_ENROLLMENT,
             LoginDisplayHostImpl::default_host()
                 ->GetAutoEnrollmentController()
                 ->state());
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerDeviceStateTest,
                        ControlFlowDeviceDisabled) {
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   AutoEnrollmentCheckScreen* screen =
       AutoEnrollmentCheckScreen::Get(WizardController::default_controller());
   EXPECT_EQ(screen,
             WizardController::default_controller()->current_screen());
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   screen->Start();
 
   // Wait for auto-enrollment controller to encounter the connection error.
   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 
   // The error screen shows up if device state could not be retrieved.
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
   EXPECT_EQ(GetErrorScreen(),
             WizardController::default_controller()->current_screen());
   base::DictionaryValue device_state;
   device_state.SetBoolean(policy::kDeviceStateDisabled, true);
   device_state.SetString(policy::kDeviceStateDisabledMessage, kDisabledMessage);
   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
                                         device_state);
   EXPECT_CALL(*device_disabled_screen_actor_, Show(kDisabledMessage)).Times(1);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   ResetAutoEnrollmentCheckScreen();
 
   // Make sure the device disabled screen is shown.
   CheckCurrentScreen(WizardController::kDeviceDisabledScreenName);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
@@ skipping 130 matching lines @@
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
                             ""))
       .Times(1);
 
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
-
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
-  OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 }
 
 
 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
                        ControlFlowEnrollmentBack) {
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
                             ""))
       .Times(1);
 
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::NETWORK_CONNECTED);
+  OnExit(BaseScreenDelegate::NETWORK_CONNECTED);
 
   CheckCurrentScreen(WizardController::kEulaScreenName);
   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::EULA_ACCEPTED);
+  OnExit(BaseScreenDelegate::EULA_ACCEPTED);
 
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
   CheckCurrentScreen(WizardController::kUpdateScreenName);
   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Show()).Times(1);
-  OnExit(ScreenObserver::UPDATE_INSTALLED);
+  OnExit(BaseScreenDelegate::UPDATE_INSTALLED);
 
   CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(1);
-  OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
+  OnExit(BaseScreenDelegate::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
   CheckCurrentScreen(WizardController::kEnrollmentScreenName);
-  OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_BACK);
+  OnExit(BaseScreenDelegate::ENTERPRISE_ENROLLMENT_BACK);
 
   CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 }
 
 class WizardControllerOobeResumeTest : public WizardControllerTest {
  protected:
   WizardControllerOobeResumeTest() {}
   // Overriden from InProcessBrowserTest:
   virtual void SetUpOnMainThread() override {
     WizardControllerTest::SetUpOnMainThread();
 
     // Make sure that OOBE is run as an "official" build.
     WizardController::default_controller()->is_official_build_ = true;
 
     // Clear portal list (as it is by default in OOBE).
     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 
     // Set up the mocks for all screens.
     MOCK(mock_network_screen_,
          kNetworkScreenName,
          MockNetworkScreen,
          MockNetworkScreenActor);
     MOCK(mock_enrollment_screen_,
          kEnrollmentScreenName,
          MockEnrollmentScreen,
          MockEnrollmentScreenActor);
   }
 
-  void OnExit(ScreenObserver::ExitCodes exit_code) {
+  void OnExit(BaseScreenDelegate::ExitCodes exit_code) {
     WizardController::default_controller()->OnExit(exit_code);
   }
 
   std::string GetFirstScreenName() {
     return WizardController::default_controller()->first_screen_name();
   }
 
   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
       mock_network_screen_;
   MockOutShowHide<MockEnrollmentScreen,
@@ skipping 30 matching lines @@
 // TODO(dzhioev): Add test emaulating device with wrong HWID.
 
 // TODO(nkostylev): Add test for WebUI accelerators http://crosbug.com/22571
 
 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
 // UI and logic is ready. http://crbug.com/127016
 
 // TODO(dzhioev): Add tests for controller/host pairing flow.
 // http://crbug.com/375191
 
-COMPILE_ASSERT(ScreenObserver::EXIT_CODES_COUNT == 24,
+COMPILE_ASSERT(BaseScreenDelegate::EXIT_CODES_COUNT == 24,
                add_tests_for_new_control_flow_you_just_introduced);
 
 }  // namespace chromeos