Generalize screen getting/instantiation code.

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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 194 matching lines @@
 
   H* actor() const { return actor_.get(); }
 
   MOCK_METHOD0(Show, void());
   MOCK_METHOD0(Hide, void());
 
  private:
   scoped_ptr<H> actor_;
 };
 
-#define MOCK(mock_var, screen_name, mocked_class, actor_class)                 \
-  mock_var = new MockOutShowHide<mocked_class, actor_class>(                   \
-      WizardController::default_controller(), new actor_class);                \
-  WizardController::default_controller()->screen_name.reset(mock_var);         \
-  EXPECT_CALL(*mock_var, Show()).Times(0);                                     \
+#define MOCK(mock_var, screen_name, mocked_class, actor_class)               \
+  mock_var = new MockOutShowHide<mocked_class, actor_class>(                 \
+      WizardController::default_controller(), new actor_class);              \
+  WizardController::default_controller()                                     \
+      ->screens_[WizardController::screen_name] = make_linked_ptr(mock_var); \
+  EXPECT_CALL(*mock_var, Show()).Times(0);                                   \
   EXPECT_CALL(*mock_var, Hide()).Times(0);
 
 class WizardControllerTest : public WizardInProcessBrowserTest {
  protected:
   WizardControllerTest() : WizardInProcessBrowserTest(
       WizardController::kTestNoScreenName) {}
   virtual ~WizardControllerTest() {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
     AccessibilityManager::Get()->
@@ skipping 33 matching lines @@
 
   bool JSExecuteBooleanExpression(const std::string& expression) {
     bool result;
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         GetWebContents(),
         "window.domAutomationController.send(!!(" + expression + "));",
         &result));
     return result;
   }
 
+  void CheckCurrentScreen(const std::string& screen_name) {
+    EXPECT_EQ(WizardController::default_controller()->GetScreen(screen_name),
+              WizardController::default_controller()->current_screen());
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerTest, SwitchLanguage) {
   ASSERT_TRUE(WizardController::default_controller() != NULL);
   WizardController::default_controller()->AdvanceToScreen(
       WizardController::kNetworkScreenName);
 
   // Checking the default locale. Provided that the profile is cleared in SetUp.
@@ skipping 100 matching lines @@
   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_, network_screen_,
-         MockNetworkScreen, MockNetworkScreenActor);
-    MOCK(mock_update_screen_, update_screen_,
-         MockUpdateScreen, MockUpdateScreenActor);
-    MOCK(mock_eula_screen_, eula_screen_, MockEulaScreen, MockEulaScreenActor);
-    MOCK(mock_enrollment_screen_, enrollment_screen_,
-         MockEnrollmentScreen, MockEnrollmentScreenActor);
-    MOCK(mock_auto_enrollment_check_screen_, auto_enrollment_check_screen_,
-         MockAutoEnrollmentCheckScreen, MockAutoEnrollmentCheckScreenActor);
+    MOCK(mock_network_screen_,
+         kNetworkScreenName,
+         MockNetworkScreen,
+         MockNetworkScreenActor);
+    MOCK(mock_update_screen_,
+         kUpdateScreenName,
+         MockUpdateScreen,
+         MockUpdateScreenActor);
+    MOCK(mock_eula_screen_,
+         kEulaScreenName,
+         MockEulaScreen,
+         MockEulaScreenActor);
+    MOCK(mock_enrollment_screen_,
+         kEnrollmentScreenName,
+         MockEnrollmentScreen,
+         MockEnrollmentScreenActor);
+    MOCK(mock_auto_enrollment_check_screen_,
+         kAutoEnrollmentCheckScreenName,
+         MockAutoEnrollmentCheckScreen,
+         MockAutoEnrollmentCheckScreenActor);
 
     // Switch to the initial screen.
     EXPECT_EQ(NULL, WizardController::default_controller()->current_screen());
     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
     WizardController::default_controller()->AdvanceToScreen(
         WizardController::kNetworkScreenName);
   }
 
   virtual void TearDown() {
     if (fallback_fetcher_factory_) {
@@ skipping 40 matching lines @@
     if (!WizardController::default_controller()
              ->SetOnTimeZoneResolvedForTesting(
                  base::Bind(&TimeZoneTestRunner::OnResolved,
                             base::Unretained(runner.get()))))
       return;
 
     runner->Run();
   }
 
   void ResetAutoEnrollmentCheckScreen() {
-    WizardController::default_controller()->
-        auto_enrollment_check_screen_.reset();
+    WizardController::default_controller()->screens_.erase(
+        WizardController::kAutoEnrollmentCheckScreenName);
   }
 
   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
       mock_network_screen_;
   MockOutShowHide<MockUpdateScreen, MockUpdateScreenActor>* mock_update_screen_;
   MockOutShowHide<MockEulaScreen, MockEulaScreenActor>* mock_eula_screen_;
   MockOutShowHide<MockEnrollmentScreen,
       MockEnrollmentScreenActor>* mock_enrollment_screen_;
   MockOutShowHide<MockAutoEnrollmentCheckScreen,
       MockAutoEnrollmentCheckScreenActor>* mock_auto_enrollment_check_screen_;
 
  private:
   NetworkPortalDetectorTestImpl* network_portal_detector_;
 
   // Use a test factory as a fallback so we don't have to deal with other
   // requests.
   scoped_ptr<WizardControllerTestURLFetcherFactory> fallback_fetcher_factory_;
   scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   EXPECT_TRUE(GetGeolocationProvider());
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(
-      WizardController::default_controller()->GetAutoEnrollmentCheckScreen(),
-      WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
   OnExit(ScreenObserver::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) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(
-      WizardController::default_controller()->GetAutoEnrollmentCheckScreen(),
-      WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kAutoEnrollmentCheckScreenName);
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(0);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(
-      WizardController::default_controller()->GetAutoEnrollmentCheckScreen(),
-      WizardController::default_controller()->current_screen());
+  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);
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
-            WizardController::default_controller()->current_screen());
+  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) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowEnrollmentCompleted) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
-  EnrollmentScreen* screen =
-      WizardController::default_controller()->GetEnrollmentScreen();
-  EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
                        ControlFlowAutoEnrollmentCompleted) {
   WizardController::default_controller()->SkipPostLoginScreensForTesting();
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 
   UserContext user_context(kUsername);
   user_context.SetKey(Key(kPassword));
   user_context.SetUserIDHash(user_context.GetUserID());
   LoginUtils::Set(new TestLoginUtils(user_context));
   MockAuthStatusConsumer mock_consumer;
 
   // Must have a pending signin to resume after auto-enrollment:
   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   ExistingUserController::current_controller()->DoAutoEnrollment();
   ExistingUserController::current_controller()->set_login_status_consumer(
       &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();
 
-  EnrollmentScreen* screen =
-      WizardController::default_controller()->GetEnrollmentScreen();
-  EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
+  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);
   // 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) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 
-  WrongHWIDScreen* screen =
-      WizardController::default_controller()->GetWrongHWIDScreen();
-  EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kWrongHWIDScreenName);
 
   // After warning is skipped, user returns to sign-in screen.
   // And this destroys WizardController.
   OnExit(ScreenObserver::WRONG_HWID_WARNING_SKIPPED);
   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 }
 
 class WizardControllerEnrollmentFlowTest : public WizardControllerFlowTest {
  protected:
   WizardControllerEnrollmentFlowTest() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     WizardControllerFlowTest::SetUpCommandLine(command_line);
 
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnableForcedReEnrollment,
         chromeos::AutoEnrollmentController::kForcedReEnrollmentAlways);
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnrollmentInitialModulus, "1");
     command_line->AppendSwitchASCII(
         switches::kEnterpriseEnrollmentModulusLimit, "2");
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnrollmentFlowTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerEnrollmentFlowTest,
                        ControlFlowForcedReEnrollment) {
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(ScreenObserver::NETWORK_CONNECTED);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
   AutoEnrollmentCheckScreen* screen =
       WizardController::default_controller()->GetAutoEnrollmentCheckScreen();
   EXPECT_EQ(screen,
             WizardController::default_controller()->current_screen());
   EXPECT_CALL(*mock_auto_enrollment_check_screen_, Hide()).Times(1);
   screen->Start();
@@ skipping 12 matching lines @@
   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);
 
   ResetAutoEnrollmentCheckScreen();
 
   // Make sure enterprise enrollment page shows up.
-  EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 
   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 }
 
 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
  protected:
   WizardControllerBrokenLocalStateTest()
       : fake_session_manager_client_(NULL) {
   }
@@ skipping 99 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
                        ProxyAuthDialogOnSigninScreen) {
   content::WindowedNotificationObserver auth_needed_waiter(
       chrome::NOTIFICATION_AUTH_NEEDED,
       content::NotificationService::AllSources());
 
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
 
   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
   auth_needed_waiter.Wait();
 }
 
 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
  protected:
   WizardControllerKioskFlowTest() {}
 
   // Overridden from InProcessBrowserTest:
@@ skipping 12 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
                        ControlFlowKioskForcedEnrollment) {
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
                             ""))
       .Times(1);
 
   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
   OnExit(ScreenObserver::NETWORK_CONNECTED);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(
-      WizardController::default_controller()->GetAutoEnrollmentCheckScreen(),
-      WizardController::default_controller()->current_screen());
+  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);
 
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
-  EnrollmentScreen* screen =
-      WizardController::default_controller()->GetEnrollmentScreen();
-  EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   OnExit(ScreenObserver::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);
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
   // Let update screen smooth time process (time = 0ms).
   content::RunAllPendingInMessageLoop();
 
-  EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
-            WizardController::default_controller()->current_screen());
+  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);
 
-  EXPECT_EQ(
-      WizardController::default_controller()->GetAutoEnrollmentCheckScreen(),
-      WizardController::default_controller()->current_screen());
+  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);
 
   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 
   // Make sure enterprise enrollment page shows up right after update screen.
-  EnrollmentScreen* screen =
-      WizardController::default_controller()->GetEnrollmentScreen();
-  EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_BACK);
 
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  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_, network_screen_,
-         MockNetworkScreen, MockNetworkScreenActor);
-    MOCK(mock_enrollment_screen_, enrollment_screen_,
-         MockEnrollmentScreen, MockEnrollmentScreenActor);
+    MOCK(mock_network_screen_,
+         kNetworkScreenName,
+         MockNetworkScreen,
+         MockNetworkScreenActor);
+    MOCK(mock_enrollment_screen_,
+         kEnrollmentScreenName,
+         MockEnrollmentScreen,
+         MockEnrollmentScreenActor);
   }
 
   void OnExit(ScreenObserver::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,
       MockEnrollmentScreenActor>* mock_enrollment_screen_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WizardControllerOobeResumeTest);
 };
 
 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
                        PRE_ControlFlowResumeInterruptedOobe) {
   // Switch to the initial screen.
   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
   WizardController::default_controller()->AdvanceToScreen(
       WizardController::kNetworkScreenName);
-  EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kNetworkScreenName);
   EXPECT_CALL(*mock_enrollment_screen_->actor(),
               SetParameters(mock_enrollment_screen_,
                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
-                            ""))
-      .Times(1);
+                            "")).Times(1);
   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 
   WizardController::default_controller()->AdvanceToScreen(
       WizardController::kEnrollmentScreenName);
-  EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
-            WizardController::default_controller()->current_screen());
+  CheckCurrentScreen(WizardController::kEnrollmentScreenName);
 }
 
 IN_PROC_BROWSER_TEST_F(WizardControllerOobeResumeTest,
                        ControlFlowResumeInterruptedOobe) {
   EXPECT_EQ(WizardController::kEnrollmentScreenName, GetFirstScreenName());
 }
 
 // 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 == 23,
                add_tests_for_new_control_flow_you_just_introduced);
 
 }  // namespace chromeos