[cros] Cleanup: remove LoginUtils

chrome/browser/chromeos/login/existing_user_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
+#include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/help_app_launcher.h"
 #include "chrome/browser/chromeos/login/helper.h"
-#include "chrome/browser/chromeos/login/mock_login_utils.h"
 #include "chrome/browser/chromeos/login/screens/mock_base_screen_delegate.h"
+#include "chrome/browser/chromeos/login/session/user_session_manager.h"
+#include "chrome/browser/chromeos/login/session/user_session_manager_test_api.h"
 #include "chrome/browser/chromeos/login/supervised/supervised_user_creation_screen.h"
 #include "chrome/browser/chromeos/login/ui/mock_login_display.h"
 #include "chrome/browser/chromeos/login/ui/mock_login_display_host.h"
-#include "chrome/browser/chromeos/login/user_flow.h"
-#include "chrome/browser/chromeos/login/users/mock_user_manager.h"
+#include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
 #include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/ui/webui/chromeos/login/supervised_user_creation_screen_handler.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
-#include "chromeos/login/auth/authenticator.h"
 #include "chromeos/login/auth/key.h"
-#include "chromeos/login/auth/mock_authenticator.h"
 #include "chromeos/login/auth/mock_url_fetchers.h"
 #include "chromeos/login/auth/user_context.h"
 #include "chromeos/login/user_names.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_store.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
 #include "components/policy/core/common/cloud/policy_builder.h"
@@ skipping 15 matching lines @@
 using ::testing::WithArg;
 using ::testing::_;
 
 namespace em = enterprise_management;
 
 namespace chromeos {
 
 namespace {
 
 const char kUsername[] = "test_user@gmail.com";
-const char kNewUsername[] = "test_new_user@gmail.com";
 const char kSupervisedUserID[] = "supervised_user@locally-managed.localhost";
 const char kPassword[] = "test_password";
 
 const char kPublicSessionAccountId[] = "public_session_user@localhost";
 const int kAutoLoginNoDelay = 0;
 const int kAutoLoginShortDelay = 1;
 const int kAutoLoginLongDelay = 10000;
 
-ACTION_P(CreateAuthenticator, user_context) {
-  return new MockAuthenticator(arg0, user_context);
-}
-
-void DeleteUserFlow(UserFlow* user_flow) {
-  delete user_flow;
-}
-
 // Wait for cros settings to become permanently untrusted and run |callback|.
 void WaitForPermanentlyUntrustedStatusAndRun(const base::Closure& callback) {
   while (true) {
     const CrosSettingsProvider::TrustedStatus status =
         CrosSettings::Get()->PrepareTrustedValues(base::Bind(
             &WaitForPermanentlyUntrustedStatusAndRun,
             callback));
     switch (status) {
       case CrosSettingsProvider::PERMANENTLY_UNTRUSTED:
         callback.Run();
         return;
       case CrosSettingsProvider::TEMPORARILY_UNTRUSTED:
         return;
       case CrosSettingsProvider::TRUSTED:
         content::RunAllPendingInMessageLoop();
         break;
     }
   }
 }
 
 }  // namespace
 
 class ExistingUserControllerTest : public policy::DevicePolicyCrosBrowserTest {
  protected:
-  ExistingUserControllerTest()
-      : mock_login_display_(NULL), mock_user_manager_(NULL) {}
+  ExistingUserControllerTest() : mock_login_display_(NULL) {}
 
   ExistingUserController* existing_user_controller() {
     return ExistingUserController::current_controller();
   }
 
   const ExistingUserController* existing_user_controller() const {
     return ExistingUserController::current_controller();
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     SetUpSessionManager();
 
     DevicePolicyCrosBrowserTest::SetUpInProcessBrowserTestFixture();
 
-    mock_login_utils_ = new MockLoginUtils();
-    LoginUtils::Set(mock_login_utils_);
-    EXPECT_CALL(*mock_login_utils_, DelegateDeleted(_))
-        .Times(1);
-
     mock_login_display_host_.reset(new MockLoginDisplayHost());
     mock_login_display_ = new MockLoginDisplay();
     SetUpLoginDisplay();
   }
 
+  void TearDown() override { user_manager_enabler_.reset(); }
+
   virtual void SetUpSessionManager() {
   }
 
   virtual void SetUpLoginDisplay() {
     EXPECT_CALL(*mock_login_display_host_.get(), CreateLoginDisplay(_))
         .Times(1)
         .WillOnce(Return(mock_login_display_));
     EXPECT_CALL(*mock_login_display_host_.get(), GetNativeWindow())
         .Times(1)
         .WillOnce(ReturnNull());
     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
         .Times(1);
     EXPECT_CALL(*mock_login_display_, Init(_, false, true, true))
         .Times(1);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kLoginManager);
+    command_line->AppendSwitch(switches::kForceLoginManagerInTests);
   }
 
   virtual void SetUpUserManager() {
-    // Replace the UserManager singleton with a mock.
-    mock_user_manager_ = new MockUserManager;
     user_manager_enabler_.reset(
-        new ScopedUserManagerEnabler(mock_user_manager_));
-    EXPECT_CALL(*mock_user_manager_, IsKnownUser(kUsername))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(*mock_user_manager_, IsKnownUser(kNewUsername))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, IsLoggedInAsPublicAccount())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, IsSessionStarted())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(*mock_user_manager_, Shutdown())
-        .Times(1);
-    EXPECT_CALL(*mock_user_manager_, FindUser(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(ReturnNull());
+        new ScopedUserManagerEnabler(new chromeos::FakeUserManager()));
+    GetFakeUserManager()->AddUser(kUsername);
   }
 
   void SetUpOnMainThread() override {
-    testing_profile_.reset(new TestingProfile());
     SetUpUserManager();
     existing_user_controller_.reset(
         new ExistingUserController(mock_login_display_host_.get()));
     ASSERT_EQ(existing_user_controller(), existing_user_controller_.get());
     existing_user_controller_->Init(user_manager::UserList());
-    profile_prepared_cb_ =
-        base::Bind(&ExistingUserController::OnProfilePrepared,
-                   base::Unretained(existing_user_controller()),
-                   testing_profile_.get(),
-                   false);
   }
 
   void TearDownOnMainThread() override {
     // ExistingUserController must be deleted before the thread is cleaned up:
     // If there is an outstanding login attempt when ExistingUserController is
     // deleted, its LoginPerformer instance will be deleted, which in turn
     // deletes its OnlineAttemptHost instance.  However, OnlineAttemptHost must
     // be deleted on the UI thread.
     existing_user_controller_.reset();
     DevicePolicyCrosBrowserTest::InProcessBrowserTest::TearDownOnMainThread();
-    testing_profile_.reset(NULL);
     user_manager_enabler_.reset();
   }
 
   void ExpectLoginFailure() {
     EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
         .Times(1);
     EXPECT_CALL(*mock_login_display_,
                 ShowError(IDS_LOGIN_ERROR_OWNER_KEY_LOST,
                           1,
                           HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT))
@@ skipping 19 matching lines @@
     return existing_user_controller()->is_login_in_progress_;
   }
 
   scoped_ptr<ExistingUserController> existing_user_controller_;
 
   // |mock_login_display_| is owned by the ExistingUserController, which calls
   // CreateLoginDisplay() on the |mock_login_display_host_| to get it.
   MockLoginDisplay* mock_login_display_;
   scoped_ptr<MockLoginDisplayHost> mock_login_display_host_;
 
-  // Owned by LoginUtilsWrapper.
-  MockLoginUtils* mock_login_utils_;
-
-  MockUserManager* mock_user_manager_;  // Not owned.
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
 
-  scoped_ptr<TestingProfile> testing_profile_;
-
   // Mock URLFetcher.
   MockURLFetcherFactory<SuccessFetcher> factory_;
 
-  base::Callback<void(void)> profile_prepared_cb_;
+ private:
+  chromeos::FakeUserManager* GetFakeUserManager() {
+    return static_cast<chromeos::FakeUserManager*>(
+        user_manager::UserManager::Get());
+  }
 
- private:
   DISALLOW_COPY_AND_ASSIGN(ExistingUserControllerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerTest, ExistingUserLogin) {
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
       .Times(2);
   UserContext user_context(kUsername);
   user_context.SetKey(Key(kPassword));
   user_context.SetUserIDHash(kUsername);
-  EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
-      .Times(1)
-      .WillOnce(WithArg<0>(CreateAuthenticator(user_context)));
-  EXPECT_CALL(*mock_login_utils_, PrepareProfile(user_context, _, _, _))
-      .Times(1)
-      .WillOnce(InvokeWithoutArgs(&profile_prepared_cb_,
-                                  &base::Callback<void(void)>::Run));
+  test::UserSessionManagerTestApi session_manager_test_api(
+      UserSessionManager::GetInstance());
+  session_manager_test_api.InjectStubUserContext(user_context);
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
       .Times(1);
   EXPECT_CALL(*mock_login_display_host_,
               StartWizard(WizardController::kTermsOfServiceScreenName))
       .Times(0);
-  EXPECT_CALL(*mock_user_manager_, IsCurrentUserNew())
-      .Times(AnyNumber())
-      .WillRepeatedly(Return(false));
+
+  content::WindowedNotificationObserver profile_prepared_observer(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources());
   existing_user_controller()->Login(user_context, SigninSpecifics());
+
+  profile_prepared_observer.Wait();
   content::RunAllPendingInMessageLoop();
 }
 
 // Verifies that when the cros settings are untrusted, no new session can be
 // started.
 class ExistingUserControllerUntrustedTest : public ExistingUserControllerTest {
  public:
   ExistingUserControllerUntrustedTest();
 
   void SetUpInProcessBrowserTestFixture() override;
@@ skipping 45 matching lines @@
   existing_user_controller()->Login(user_context, SigninSpecifics());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        SupervisedUserCreationForbidden) {
   MockBaseScreenDelegate mock_base_screen_delegate;
   SupervisedUserCreationScreenHandler supervised_user_creation_screen_handler;
   SupervisedUserCreationScreen supervised_user_creation_screen(
       &mock_base_screen_delegate, &supervised_user_creation_screen_handler);
 
-  EXPECT_CALL(*mock_user_manager_, SetUserFlow(kUsername, _))
-      .Times(1)
-      .WillOnce(WithArg<1>(Invoke(DeleteUserFlow)));
   supervised_user_creation_screen.AuthenticateManager(kUsername, kPassword);
 }
 
 MATCHER_P(HasDetails, expected, "") {
   return expected == *content::Details<const std::string>(arg).ptr();
 }
 
 class ExistingUserControllerPublicSessionTest
     : public ExistingUserControllerTest {
  protected:
@@ skipping 73 matching lines @@
       .WillRepeatedly(ReturnNull());
     EXPECT_CALL(*mock_login_display_host_.get(), OnPreferencesChanged())
       .Times(AnyNumber());
     EXPECT_CALL(*mock_login_display_, Init(_, _, _, _))
       .Times(AnyNumber());
   }
 
   void SetUpUserManager() override {}
 
   void ExpectSuccessfulLogin(const UserContext& user_context) {
-    EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
-        .Times(AnyNumber());
-    EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
-        .Times(1)
-        .WillOnce(WithArg<0>(CreateAuthenticator(user_context)));
-    EXPECT_CALL(*mock_login_utils_, PrepareProfile(user_context, _, _, _))
-        .Times(1)
-        .WillOnce(InvokeWithoutArgs(&profile_prepared_cb_,
-                                    &base::Callback<void(void)>::Run));
-    EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
-        .Times(1);
+    test::UserSessionManagerTestApi session_manager_test_api(
+        UserSessionManager::GetInstance());
+    session_manager_test_api.InjectStubUserContext(user_context);
     EXPECT_CALL(*mock_login_display_host_,
                 StartWizard(WizardController::kTermsOfServiceScreenName))
         .Times(0);
+    EXPECT_CALL(*mock_login_display_, SetUIEnabled(false)).Times(AnyNumber());
+    EXPECT_CALL(*mock_login_display_, SetUIEnabled(true)).Times(AnyNumber());
   }
 
   void SetAutoLoginPolicy(const std::string& username, int delay) {
     // Wait until ExistingUserController has finished auto-login
     // configuration by observing the same settings that trigger
     // ConfigurePublicSessionAutoLogin.
 
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
 
     // If both settings have changed we need to wait for both to
@@ skipping 68 matching lines @@
   EXPECT_EQ(kAutoLoginLongDelay, auto_login_delay());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_TRUE(auto_login_timer()->IsRunning());
 
   // Unset the policy.
   SetAutoLoginPolicy("", 0);
   EXPECT_EQ("", auto_login_username());
   EXPECT_EQ(0, auto_login_delay());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
+
+  // This test is configured with the real user manager but empty user list
+  // initially. So network OOBE screen is initialized.
+  // Need to reset it manually so that we don't end up with CrosSettings
+  // observer that wasn't removed.
+  WizardController* controller = WizardController::default_controller();

[Dmitry Polukhin, 2015/02/03 11:33:07]

What do you think about moving this logic to test teardown?

[Nikita (slow), 2015/02/03 13:12:26]

Done.

+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        AutoLoginNoDelay) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
                            public_session_user_id_);
   user_context.SetUserIDHash(user_context.GetUserID());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
 
   // Start auto-login and wait for login tasks to complete.
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginNoDelay);
   content::RunAllPendingInMessageLoop();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        AutoLoginShortDelay) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
                            public_session_user_id_);
   user_context.SetUserIDHash(user_context.GetUserID());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
+
+  content::WindowedNotificationObserver profile_prepared_observer(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources());
+
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginShortDelay);
   ASSERT_TRUE(auto_login_timer());
   // Don't assert that timer is running: with the short delay sometimes
   // the trigger happens before the assert.  We've already tested that
   // the timer starts when it should.
 
   // Wait for the timer to fire.
   base::RunLoop runner;
   base::OneShotTimer<base::RunLoop> timer;
   timer.Start(FROM_HERE,
               base::TimeDelta::FromMilliseconds(kAutoLoginShortDelay + 1),
               runner.QuitClosure());
   runner.Run();
 
+  profile_prepared_observer.Wait();
+
+  // This test is configured with the real user manager but empty user list
+  // initially. So network OOBE screen is initialized.
+  // Need to reset it manually so that we don't end up with CrosSettings
+  // observer that wasn't removed.
+  WizardController* controller = WizardController::default_controller();
+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
+
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        LoginStopsAutoLogin) {
   // Set up mocks to check login success.
   UserContext user_context(kUsername);
   user_context.SetKey(Key(kPassword));
   user_context.SetUserIDHash(user_context.GetUserID());
   ExpectSuccessfulLogin(user_context);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
+  content::WindowedNotificationObserver profile_prepared_observer(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources());
+
   // Log in and check that it stopped the timer.
   existing_user_controller()->Login(user_context, SigninSpecifics());
   EXPECT_TRUE(is_login_in_progress());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 
+  profile_prepared_observer.Wait();
+
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
+
+  // This test is configured with the real user manager but empty user list.
+  // When logging in this test we end up on user image screen.
+  WizardController* controller = WizardController::default_controller();
+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        GuestModeLoginStopsAutoLogin) {
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
       .Times(2);
   UserContext user_context(kUsername);
   user_context.SetKey(Key(kPassword));
-  EXPECT_CALL(*mock_login_utils_, CreateAuthenticator(_))
-      .Times(1)
-      .WillOnce(WithArg<0>(CreateAuthenticator(user_context)));
+  test::UserSessionManagerTestApi session_manager_test_api(
+      UserSessionManager::GetInstance());
+  session_manager_test_api.InjectStubUserContext(user_context);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
   // Login and check that it stopped the timer.
   existing_user_controller()->Login(UserContext(user_manager::USER_TYPE_GUEST,
                                                 std::string()),
                                     SigninSpecifics());
   EXPECT_TRUE(is_login_in_progress());
@@ skipping 15 matching lines @@
   user_context.SetKey(Key(kPassword));
   user_context.SetUserIDHash(user_context.GetUserID());
   ExpectSuccessfulLogin(user_context);
   EXPECT_CALL(*mock_login_display_host_, OnCompleteLogin())
       .Times(1);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
+  content::WindowedNotificationObserver profile_prepared_observer(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources());
+
   // Check that login completes and stops the timer.
   existing_user_controller()->CompleteLogin(user_context);
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 
+  profile_prepared_observer.Wait();
+
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
+
+  // This test is configured with the real user manager but empty user list.
+  // When logging in this test we end up on user image screen.
+  WizardController* controller = WizardController::default_controller();
+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        PublicSessionLoginStopsAutoLogin) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
                            public_session_user_id_);
   user_context.SetUserIDHash(user_context.GetUserID());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
+  content::WindowedNotificationObserver profile_prepared_observer(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources());
+
   // Login and check that it stopped the timer.
   existing_user_controller()->Login(
       UserContext(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
                   public_session_user_id_),
       SigninSpecifics());
 
   EXPECT_TRUE(is_login_in_progress());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 
+  profile_prepared_observer.Wait();
+
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        LoginForbiddenWhenUntrusted) {
   // Make cros settings untrusted.
   MakeCrosSettingsPermanentlyUntrusted();
 
   // Check that the attempt to start a public session fails with an error.
   ExpectLoginFailure();
   UserContext user_context(kUsername);
   user_context.SetKey(Key(kPassword));
   user_context.SetUserIDHash(user_context.GetUserID());
   existing_user_controller()->Login(user_context, SigninSpecifics());
+
+  // This test is configured with the real user manager but empty user list
+  // initially. So network OOBE screen is initialized.
+  // Need to reset it manually so that we don't end up with CrosSettings
+  // observer that wasn't removed.
+  WizardController* controller = WizardController::default_controller();
+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        NoAutoLoginWhenUntrusted) {
   // Start the public session timer.
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   existing_user_controller()->OnSigninScreenReady();
   EXPECT_TRUE(auto_login_timer());
 
   // Make cros settings untrusted.
   MakeCrosSettingsPermanentlyUntrusted();
 
   // Check that when the timer fires, auto-login fails with an error.
   ExpectLoginFailure();
   FireAutoLogin();
+
+  // This test is configured with the real user manager but empty user list
+  // initially. So network OOBE screen is initialized.
+  // Need to reset it manually so that we don't end up with CrosSettings
+  // observer that wasn't removed.
+  WizardController* controller = WizardController::default_controller();
+  if (controller && controller->current_screen())
+    controller->current_screen()->Hide();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        PRE_TestLoadingPublicUsersFromLocalState) {
   // First run propagates public accounts and stores them in Local State.
 }
 
 // See http://crbug.com/393704; flaky.
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        DISABLED_TestLoadingPublicUsersFromLocalState) {
   // Second run loads list of public accounts from Local State.
 }
 
 }  // namespace chromeos