[cros] Cleanup: remove LoginUtils

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/base/locale_util.h"
 #include "chrome/browser/chromeos/boot_times_recorder.h"
 #include "chrome/browser/chromeos/first_run/first_run.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
+#include "chrome/browser/chromeos/login/auth/chrome_cryptohome_authenticator.h"
 #include "chrome/browser/chromeos/login/chrome_restart_request.h"
 #include "chrome/browser/chromeos/login/demo_mode/demo_app_launcher.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_key_manager.h"
+#include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/profile_auth_data.h"
 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter.h"
 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter_factory.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/ui/input_events_blocker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/user_flow.h"
@@ skipping 22 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_util.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
+#include "chromeos/login/auth/stub_authenticator.h"
 #include "chromeos/login/user_names.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "chromeos/network/portal_detector/network_portal_detector_strategy.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/session_manager/core/session_manager.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/user_manager/user.h"
@@ skipping 218 matching lines @@
   }
 }
 
 // static
 void UserSessionManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRLZBrand, std::string());
   registry->RegisterBooleanPref(prefs::kRLZDisabled, false);
 }
 
 UserSessionManager::UserSessionManager()
-    : delegate_(NULL),
+    : delegate_(nullptr),
+      authenticator_(nullptr),
       has_auth_cookies_(false),
       user_sessions_restored_(false),
       user_sessions_restore_in_progress_(false),
       exit_after_session_restore_(false),
       session_restore_strategy_(
           OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN),
-      running_easy_unlock_key_ops_(false) {
+      running_easy_unlock_key_ops_(false),
+      should_launch_browser_(true) {
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 }
 
 UserSessionManager::~UserSessionManager() {
   // UserManager is destroyed before singletons, so we need to check if it
   // still exists.
   // TODO(nkostylev): fix order of destruction of UserManager
   // / UserSessionManager objects.
   if (user_manager::UserManager::IsInitialized())
@@ skipping 24 matching lines @@
   const base::CommandLine user_flags(base::CommandLine::NO_PROGRAM);
   if (!about_flags::AreSwitchesIdenticalToCurrentCommandLine(
           user_flags, *base::CommandLine::ForCurrentProcess(), NULL)) {
     DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
         chromeos::login::kGuestUserName, base::CommandLine::StringVector());
   }
 
   RestartChrome(cmd_line_str);
 }
 
+scoped_refptr<Authenticator> UserSessionManager::CreateAuthenticator(
+    AuthStatusConsumer* consumer) {
+  // Screen locker needs new Authenticator instance each time.
+  if (ScreenLocker::default_screen_locker()) {
+    if (authenticator_.get())
+      authenticator_->SetConsumer(NULL);
+    authenticator_ = NULL;
+  }
+
+  if (authenticator_.get() == NULL) {
+    if (injected_user_context_) {
+      authenticator_ =
+          new StubAuthenticator(consumer, *injected_user_context_.get());
+    } else {
+      authenticator_ = new ChromeCryptohomeAuthenticator(consumer);
+    }
+  } else {
+    // TODO(nkostylev): Fix this hack by improving Authenticator dependencies.
+    authenticator_->SetConsumer(consumer);
+  }
+  return authenticator_;
+}
+
 void UserSessionManager::StartSession(
     const UserContext& user_context,
     StartSessionType start_session_type,
-    scoped_refptr<Authenticator> authenticator,
     bool has_auth_cookies,
     bool has_active_session,
     UserSessionManagerDelegate* delegate) {
-  authenticator_ = authenticator;
   delegate_ = delegate;
   start_session_type_ = start_session_type;
 
   VLOG(1) << "Starting session for " << user_context.GetUserID();
 
   PreStartSession();
   CreateUserSession(user_context, has_auth_cookies);
 
   if (!has_active_session)
     StartCrosSession();
 
   // TODO(nkostylev): Notify UserLoggedIn() after profile is actually
   // ready to be used (http://crbug.com/361528).
   NotifyUserLoggedIn();
   PrepareProfile();
 }
 
+void UserSessionManager::DelegateDeleted(UserSessionManagerDelegate* delegate) {
+  if (delegate_ == delegate)
+    delegate_ = nullptr;
+}
+
 void UserSessionManager::PerformPostUserLoggedInActions() {
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (user_manager->GetLoggedInUsers().size() == 1) {
     if (NetworkPortalDetector::IsInitialized()) {
       NetworkPortalDetector::Get()->SetStrategy(
           PortalDetectorStrategy::STRATEGY_ID_SESSION);
     }
   }
 }
 
@@ skipping 579 matching lines @@
   }
 
   UpdateEasyUnlockKeys(user_context_);
   user_context_.ClearSecrets();
 
   // Now that profile is ready, proceed to either alternative login flows or
   // launch browser.
   bool browser_launched = InitializeUserSession(profile);
 
   // TODO(nkostylev): This pointer should probably never be NULL, but it looks
-  // like LoginUtilsImpl::OnProfileCreated() may be getting called before
+  // like OnProfileCreated() may be getting called before
   // UserSessionManager::PrepareProfile() has set |delegate_| when Chrome is
   // killed during shutdown in tests -- see http://crosbug.com/18269.  Replace
   // this 'if' statement with a CHECK(delegate_) once the underlying issue is
   // resolved.
   if (delegate_)
     delegate_->OnProfilePrepared(profile, browser_launched);
 }
 
 void UserSessionManager::ActivateWizard(const std::string& screen_name) {
   LoginDisplayHost* host = LoginDisplayHostImpl::default_host();
@@ skipping 64 matching lines @@
       // Mark the device as registered., i.e. the second part of OOBE as
       // completed.
       if (!StartupUtils::IsDeviceRegistered())
         StartupUtils::MarkDeviceRegistered(base::Closure());
 
       ActivateWizard(WizardController::kTermsOfServiceScreenName);
       return false;
     }
   }
 
-  LoginUtils::Get()->DoBrowserLaunch(profile,
-                                     LoginDisplayHostImpl::default_host());
+  DoBrowserLaunch(profile, LoginDisplayHostImpl::default_host());
   return true;
 }
 
 void UserSessionManager::InitSessionRestoreStrategy() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   bool in_app_mode = chrome::IsRunningInForcedAppMode();
 
   // Are we in kiosk app mode?
   if (in_app_mode) {
     if (command_line->HasSwitch(::switches::kAppModeOAuth2Token)) {
@@ skipping 192 matching lines @@
   if (!user_already_logged_in) {
     UserContext user_context(user_id);
     user_context.SetUserIDHash(user_id_hash);
     user_context.SetIsUsingOAuth(false);
 
     // Will call OnProfilePrepared() once profile has been loaded.
     // Only handling secondary users here since primary user profile
     // (and session) has been loaded on Chrome startup.
     StartSession(user_context,
                  SECONDARY_USER_SESSION_AFTER_CRASH,
-                 NULL,   // authenticator
                  false,  // has_auth_cookies
                  true,   // has_active_session, this is restart after crash
                  this);
   } else {
     RestorePendingUserSessions();
   }
 }
 
 void UserSessionManager::NotifyPendingUserSessionsRestoreFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 142 matching lines @@
   if (login_host) {
     login_host->SetStatusAreaVisible(true);
     login_host->BeforeSessionStart();
   }
 
   BootTimesRecorder::Get()->AddLoginTimeMarker("BrowserLaunched", false);
 
   VLOG(1) << "Launching browser...";
   TRACE_EVENT0("login", "LaunchBrowser");
 
-  StartupBrowserCreator browser_creator;
-  int return_code;
-  chrome::startup::IsFirstRun first_run =
-      ::first_run::IsChromeFirstRun() ? chrome::startup::IS_FIRST_RUN
-                                      : chrome::startup::IS_NOT_FIRST_RUN;
+  if (should_launch_browser_) {
+    StartupBrowserCreator browser_creator;
+    int return_code;
+    chrome::startup::IsFirstRun first_run =
+        ::first_run::IsChromeFirstRun() ? chrome::startup::IS_FIRST_RUN
+                                        : chrome::startup::IS_NOT_FIRST_RUN;
 
-  browser_creator.LaunchBrowser(
-      *base::CommandLine::ForCurrentProcess(), profile, base::FilePath(),
-      chrome::startup::IS_PROCESS_STARTUP, first_run, &return_code);
+    browser_creator.LaunchBrowser(
+        *base::CommandLine::ForCurrentProcess(), profile, base::FilePath(),
+        chrome::startup::IS_PROCESS_STARTUP, first_run, &return_code);
 
-  // Triggers app launcher start page service to load start page web contents.
-  app_list::StartPageService::Get(profile);
+    // Triggers app launcher start page service to load start page web contents.
+    app_list::StartPageService::Get(profile);
+  } else {
+    LOG(WARNING) << "Browser hasn't been launched, should_launch_browser_"
+                 << " is false. This is normal in some tests.";
+  }
 
   // Mark login host for deletion after browser starts.  This
   // guarantees that the message loop will be referenced by the
   // browser before it is dereferenced by the login host.
   if (login_host)
     login_host->Finalize();
   user_manager::UserManager::Get()->SessionStarted();
   chromeos::BootTimesRecorder::Get()->LoginDone(
       user_manager::UserManager::Get()->IsCurrentUserNew());
 }
@@ skipping 20 matching lines @@
     const base::Closure& callback,
     InputEventsBlocker* /* input_events_blocker */,
     const locale_util::LanguageSwitchResult& /* result */) {
   callback.Run();
 }
 
 void UserSessionManager::RemoveProfileForTesting(Profile* profile) {
   default_ime_states_.erase(profile);
 }
 
+void UserSessionManager::InjectStubUserContext(
+    const UserContext& user_context) {
+  injected_user_context_.reset(new UserContext(user_context));
+  authenticator_ = NULL;
+}
+
 }  // namespace chromeos