[cros] user_manager component - move UserManagerBase and UserManager

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 13 matching lines @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/base/locale_util.h"
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/login/demo_mode/demo_app_launcher.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/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
-#include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_brand_chromeos.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/net/crl_set_fetcher.h"
 #include "chrome/browser/net/nss_context.h"
@@ skipping 11 matching lines @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/ime/input_method_manager.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/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/session_manager/core/session_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/user_manager/user.h"
+#include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 namespace chromeos {
 
 namespace {
 
 void InitLocaleAndInputMethodsForNewUser(
     PrefService* prefs,
@@ skipping 106 matching lines @@
 UserSessionManager* UserSessionManager::GetInstance() {
   return Singleton<UserSessionManager,
       DefaultSingletonTraits<UserSessionManager> >::get();
 }
 
 // static
 void UserSessionManager::OverrideHomedir() {
   // Override user homedir, check for ProfileManager being initialized as
   // it may not exist in unit tests.
   if (g_browser_process->profile_manager()) {
-    UserManager* user_manager = UserManager::Get();
+    user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     if (user_manager->GetLoggedInUsers().size() == 1) {
       base::FilePath homedir = ProfileHelper::GetProfilePathByUserIdHash(
           user_manager->GetPrimaryUser()->username_hash());
       // This path has been either created by cryptohome (on real Chrome OS
       // device) or by ProfileManager (on chromeos=1 desktop builds).
       PathService::OverrideAndCreateIfNeeded(base::DIR_HOME,
                                              homedir,
                                              true /* path is absolute */,
                                              false /* don't create */);
     }
@@ skipping 37 matching lines @@
   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::PerformPostUserLoggedInActions() {
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (user_manager->GetLoggedInUsers().size() == 1) {
     // Owner must be first user in session. DeviceSettingsService can't deal
     // with multiple user and will mix up ownership, crbug.com/230018.
     OwnerSettingsServiceFactory::GetInstance()->
         SetUsername(user_manager->GetActiveUser()->email());
 
     if (NetworkPortalDetector::IsInitialized()) {
       NetworkPortalDetector::Get()->SetStrategy(
           PortalDetectorStrategy::STRATEGY_ID_SESSION);
     }
   }
 }
 
 void UserSessionManager::RestoreAuthenticationSession(Profile* user_profile) {
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   // We need to restore session only for logged in regular (GAIA) users.
   // Note: stub user is a special case that is used for tests, running
   // linux_chromeos build on dev workstations w/o user_id parameters.
   // Stub user is considered to be a regular GAIA user but it has special
   // user_id (kStubUser) and certain services like restoring OAuth session are
   // explicitly disabled for it.
   if (!user_manager->IsUserLoggedIn() ||
       !user_manager->IsLoggedInAsRegularUser() ||
       user_manager->IsLoggedInAsStub()) {
     return;
@@ skipping 82 matching lines @@
 
 bool UserSessionManager::RespectLocalePreference(
     Profile* profile,
     const user_manager::User* user,
     scoped_ptr<locale_util::SwitchLanguageCallback> callback) const {
   // TODO(alemate): http://crbug.com/288941 : Respect preferred language list in
   // the Google user profile.
   if (g_browser_process == NULL)
     return false;
 
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (!user || (user_manager->IsUserLoggedIn() &&
                 user != user_manager->GetPrimaryUser())) {
     return false;
   }
 
   // In case of multi-profiles session we don't apply profile locale
   // because it is unsafe.
   if (user_manager->GetLoggedInUsers().size() != 1)
     return false;
 
@@ skipping 39 matching lines @@
 
   // Here we don't enable keyboard layouts for normal users. Input methods
   // are set up when the user first logs in. Then the user may customize the
   // input methods.  Hence changing input methods here, just because the user's
   // UI language is different from the login screen UI language, is not
   // desirable. Note that input method preferences are synced, so users can use
   // their farovite input methods as soon as the preferences are synced.
   //
   // For Guest mode, user locale preferences will never get initialized.
   // So input methods should be enabled somewhere.
-  const bool enable_layouts = UserManager::Get()->IsLoggedInAsGuest();
+  const bool enable_layouts =
+      user_manager::UserManager::Get()->IsLoggedInAsGuest();
   locale_util::SwitchLanguage(pref_locale,
                               enable_layouts,
                               false /* login_layouts_only */,
                               callback.Pass());
 
   return true;
 }
 
 void UserSessionManager::AddSessionStateObserver(
     UserSessionStateObserver* observer) {
@@ skipping 29 matching lines @@
     case OAuth2LoginManager::SESSION_RESTORE_NOT_STARTED:
     case OAuth2LoginManager::SESSION_RESTORE_PREPARING:
     case OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS:
       return;
   }
 
   // We should not be clearing existing token state if that was a connection
   // error. http://crbug.com/295245
   if (!connection_error) {
     // We are in one of "done" states here.
-    UserManager::Get()->SaveUserOAuthStatus(
-        UserManager::Get()->GetLoggedInUser()->email(),
+    user_manager::UserManager::Get()->SaveUserOAuthStatus(
+        user_manager::UserManager::Get()->GetLoggedInUser()->email(),
         user_status);
   }
 
   login_manager->RemoveObserver(this);
 }
 
 void UserSessionManager::OnNewRefreshTokenAvaiable(Profile* user_profile) {
   // Check if we were waiting to restart chrome.
   if (!exit_after_session_restore_)
     return;
 
   OAuth2LoginManager* login_manager =
       OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
   login_manager->RemoveObserver(this);
 
   // Mark user auth token status as valid.
-  UserManager::Get()->SaveUserOAuthStatus(
-      UserManager::Get()->GetLoggedInUser()->email(),
+  user_manager::UserManager::Get()->SaveUserOAuthStatus(
+      user_manager::UserManager::Get()->GetLoggedInUser()->email(),
       user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
 
   VLOG(1) << "Exiting after new refresh token fetched";
 
   // We need to restart cleanly in this case to make sure OAuth2 RT is actually
   // saved.
   chrome::AttemptRestart();
 }
 
 void UserSessionManager::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   bool is_running_test =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           ::switches::kTestName) ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestType);
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (type == net::NetworkChangeNotifier::CONNECTION_NONE ||
       !user_manager->IsUserLoggedIn() ||
       !user_manager->IsLoggedInAsRegularUser() ||
       user_manager->IsLoggedInAsStub() || is_running_test) {
     return;
   }
 
   // Need to iterate over all users and their OAuth2 session state.
   const user_manager::UserList& users = user_manager->GetLoggedInUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
@@ skipping 53 matching lines @@
   BootTimesLoader* btl = BootTimesLoader::Get();
   btl->AddLoginTimeMarker("StartSession-Start", false);
   DBusThreadManager::Get()->GetSessionManagerClient()->
       StartSession(user_context_.GetUserID());
   btl->AddLoginTimeMarker("StartSession-End", false);
 }
 
 void UserSessionManager::NotifyUserLoggedIn() {
   BootTimesLoader* btl = BootTimesLoader::Get();
   btl->AddLoginTimeMarker("UserLoggedIn-Start", false);
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   user_manager->UserLoggedIn(user_context_.GetUserID(),
                              user_context_.GetUserIDHash(),
                              false);
   btl->AddLoginTimeMarker("UserLoggedIn-End", false);
 }
 
 void UserSessionManager::PrepareProfile() {
   bool is_demo_session =
       DemoAppLauncher::IsDemoAppSession(user_context_.GetUserID());
 
@@ skipping 34 matching lines @@
     case Profile::CREATE_STATUS_CANCELED:
     case Profile::MAX_CREATE_STATUS:
       NOTREACHED();
       break;
   }
 }
 
 void UserSessionManager::InitProfilePreferences(
     Profile* profile,
     const UserContext& user_context) {
-  if (UserManager::Get()->IsCurrentUserNew()) {
+  if (user_manager::UserManager::Get()->IsCurrentUserNew()) {
     SetFirstLoginPrefs(profile->GetPrefs(),
                        user_context.GetPublicSessionLocale(),
                        user_context.GetPublicSessionInputMethod());
   }
 
-  if (UserManager::Get()->IsLoggedInAsSupervisedUser()) {
-    user_manager::User* active_user = UserManager::Get()->GetActiveUser();
+  if (user_manager::UserManager::Get()->IsLoggedInAsSupervisedUser()) {
+    user_manager::User* active_user =
+        user_manager::UserManager::Get()->GetActiveUser();
     std::string supervised_user_sync_id =
-        UserManager::Get()->GetSupervisedUserManager()->
-            GetUserSyncId(active_user->email());
+        ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
+            active_user->email());
     profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
                                    supervised_user_sync_id);
-  } else if (UserManager::Get()->IsLoggedInAsRegularUser()) {
+  } else if (user_manager::UserManager::Get()->IsLoggedInAsRegularUser()) {
     // Make sure that the google service username is properly set (we do this
     // on every sign in, not just the first login, to deal with existing
     // profiles that might not have it set yet).
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(profile);
     signin_manager->SetAuthenticatedUsername(user_context.GetUserID());
   }
 }
 
 void UserSessionManager::UserProfileInitialized(Profile* profile,
@@ skipping 69 matching lines @@
   CryptohomeClient* client = DBusThreadManager::Get()->GetCryptohomeClient();
   btl->AddLoginTimeMarker("TPMOwn-Start", false);
   if (cryptohome_util::TpmIsEnabled() && !cryptohome_util::TpmIsBeingOwned()) {
     if (cryptohome_util::TpmIsOwned())
       client->CallTpmClearStoredPasswordAndBlock();
     else
       client->TpmCanAttemptOwnership(EmptyVoidDBusMethodCallback());
   }
   btl->AddLoginTimeMarker("TPMOwn-End", false);
 
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (user_manager->IsLoggedInAsRegularUser()) {
     SAMLOfflineSigninLimiter* saml_offline_signin_limiter =
         SAMLOfflineSigninLimiterFactory::GetForProfile(profile);
     if (saml_offline_signin_limiter)
       saml_offline_signin_limiter->SignedIn(user_context_.GetAuthFlow());
   }
 
   profile->OnLogin();
 
   g_browser_process->platform_part()->SessionManager()->SetSessionState(
@@ skipping 103 matching lines @@
     // When switching to RLZ enabled/disabled state, clear all recorded events.
     RLZTracker::ClearRlzState();
     local_state->SetBoolean(prefs::kRLZDisabled, disabled);
   }
   // Init the RLZ library.
   int ping_delay = profile->GetPrefs()->GetInteger(
       first_run::GetPingDelayPrefName().c_str());
   // Negative ping delay means to send ping immediately after a first search is
   // recorded.
   RLZTracker::InitRlzFromProfileDelayed(
-      profile, UserManager::Get()->IsCurrentUserNew(),
-      ping_delay < 0, base::TimeDelta::FromMilliseconds(abs(ping_delay)));
+      profile,
+      user_manager::UserManager::Get()->IsCurrentUserNew(),
+      ping_delay < 0,
+      base::TimeDelta::FromMilliseconds(abs(ping_delay)));
   if (delegate_)
     delegate_->OnRlzInitialized();
 #endif
 }
 
 void UserSessionManager::InitializeCerts(Profile* profile) {
   // Now that the user profile has been initialized
   // |GetNSSCertDatabaseForProfile| is safe to be used.
   if (CertLoader::IsInitialized() && base::SysInfo::IsRunningOnChromeOS()) {
     GetNSSCertDatabaseForProfile(profile,
@@ skipping 20 matching lines @@
     bool success) {
   if (!success) {
     LOG(ERROR) << "Could not get list of active user sessions after crash.";
     // If we could not get list of active user sessions it is safer to just
     // sign out so that we don't get in the inconsistent state.
     DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
     return;
   }
 
   // One profile has been already loaded on browser start.
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   DCHECK(user_manager->GetLoggedInUsers().size() == 1);
   DCHECK(user_manager->GetActiveUser());
   std::string active_user_id = user_manager->GetActiveUser()->email();
 
   SessionManagerClient::ActiveSessionsMap::const_iterator it;
   for (it = sessions.begin(); it != sessions.end(); ++it) {
     if (active_user_id == it->first)
       continue;
     pending_user_sessions_[it->first] = it->second;
   }
@@ skipping 10 matching lines @@
   SessionManagerClient::ActiveSessionsMap::const_iterator it =
       pending_user_sessions_.begin();
   std::string user_id = it->first;
   std::string user_id_hash = it->second;
   DCHECK(!user_id.empty());
   DCHECK(!user_id_hash.empty());
   pending_user_sessions_.erase(user_id);
 
   // Check that this user is not logged in yet.
   user_manager::UserList logged_in_users =
-      UserManager::Get()->GetLoggedInUsers();
+      user_manager::UserManager::Get()->GetLoggedInUsers();
   bool user_already_logged_in = false;
   for (user_manager::UserList::const_iterator it = logged_in_users.begin();
        it != logged_in_users.end();
        ++it) {
     const user_manager::User* user = (*it);
     if (user->email() == user_id) {
       user_already_logged_in = true;
       break;
     }
   }
@@ skipping 17 matching lines @@
 
 void UserSessionManager::NotifyPendingUserSessionsRestoreFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   user_sessions_restored_ = true;
   FOR_EACH_OBSERVER(UserSessionStateObserver,
                     session_state_observer_list_,
                     PendingUserSessionsRestoreFinished());
 }
 
 }  // namespace chromeos