[cros] Move User class to user_manager component.

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/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/supervised_user_manager.h"
-#include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.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/nss_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.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/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 "components/session_manager/core/session_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
+#include "components/user_manager/user.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 namespace chromeos {
 
 namespace {
 
 void InitLocaleAndInputMethodsForNewUser(PrefService* prefs) {
   // First, we'll set kLanguagePreloadEngines.
   std::string locale = g_browser_process->GetApplicationLocale();
@@ skipping 165 matching lines @@
   // 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;
   }
 
-  User* user = ProfileHelper::Get()->GetUserByProfile(user_profile);
+  user_manager::User* user =
+      ProfileHelper::Get()->GetUserByProfile(user_profile);
   DCHECK(user);
   if (!net::NetworkChangeNotifier::IsOffline()) {
     pending_signin_restore_sessions_.erase(user->email());
     RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
   } else {
     // Even if we're online we should wait till initial
     // OnConnectionTypeChanged() call. Otherwise starting fetchers too early may
     // end up canceling all request when initial network connection type is
     // processed. See http://crbug.com/121643.
     pending_signin_restore_sessions_.insert(user->email());
@@ skipping 62 matching lines @@
     const std::string& chrome_client_secret) {
   if (!chrome::IsRunningInForcedAppMode())
     return;
 
   chrome_client_id_ = chrome_client_id;
   chrome_client_secret_ = chrome_client_secret;
 }
 
 bool UserSessionManager::RespectLocalePreference(
     Profile* profile,
-    const User* user,
+    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();
   if ((user == NULL) || (user != user_manager->GetPrimaryUser()) ||
       (!user->is_profile_created()))
     return false;
@@ skipping 65 matching lines @@
 
 void UserSessionManager::RemoveSessionStateObserver(
     UserSessionStateObserver* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   session_state_observer_list_.RemoveObserver(observer);
 }
 
 void UserSessionManager::OnSessionRestoreStateChanged(
     Profile* user_profile,
     OAuth2LoginManager::SessionRestoreState state) {
-  User::OAuthTokenStatus user_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
+  user_manager::User::OAuthTokenStatus user_status =
+      user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN;
   OAuth2LoginManager* login_manager =
       OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
 
   bool connection_error = false;
   switch (state) {
     case OAuth2LoginManager::SESSION_RESTORE_DONE:
-      user_status = User::OAUTH2_TOKEN_STATUS_VALID;
+      user_status = user_manager::User::OAUTH2_TOKEN_STATUS_VALID;
       break;
     case OAuth2LoginManager::SESSION_RESTORE_FAILED:
-      user_status = User::OAUTH2_TOKEN_STATUS_INVALID;
+      user_status = user_manager::User::OAUTH2_TOKEN_STATUS_INVALID;
       break;
     case OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED:
       connection_error = true;
       break;
     case OAuth2LoginManager::SESSION_RESTORE_NOT_STARTED:
     case OAuth2LoginManager::SESSION_RESTORE_PREPARING:
     case OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS:
       return;
   }
 
@@ skipping 14 matching lines @@
   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::OAUTH2_TOKEN_STATUS_VALID);
+      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();
   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 UserList& users = user_manager->GetLoggedInUsers();
-  for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
+  const user_manager::UserList& users = user_manager->GetLoggedInUsers();
+  for (user_manager::UserList::const_iterator it = users.begin();
+       it != users.end();
+       ++it) {
     if (!(*it)->is_profile_created())
       continue;
 
     Profile* user_profile = ProfileHelper::Get()->GetProfileByUser(*it);
     bool should_restore_session =
         pending_signin_restore_sessions_.find((*it)->email()) !=
         pending_signin_restore_sessions_.end();
     OAuth2LoginManager* login_manager =
         OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
     if (login_manager->state() ==
@@ skipping 97 matching lines @@
       break;
   }
 }
 
 void UserSessionManager::InitProfilePreferences(Profile* profile,
                                             const std::string& user_id) {
   if (UserManager::Get()->IsCurrentUserNew())
     SetFirstLoginPrefs(profile->GetPrefs());
 
   if (UserManager::Get()->IsLoggedInAsSupervisedUser()) {
-    User* active_user = UserManager::Get()->GetActiveUser();
+    user_manager::User* active_user = UserManager::Get()->GetActiveUser();
     std::string supervised_user_sync_id =
         UserManager::Get()->GetSupervisedUserManager()->
             GetUserSyncId(active_user->email());
     profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
                                    supervised_user_sync_id);
   } else if (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 =
@@ skipping 80 matching lines @@
   // Send the notification before creating the browser so additional objects
   // that need the profile (e.g. the launcher) can be created first.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile));
 
   InitializeCertsForPrimaryUser(profile);
 
   // Initialize RLZ only for primary user.
-  const User* user = ProfileHelper::Get()->GetUserByProfile(profile);
+  const user_manager::User* user =
+      ProfileHelper::Get()->GetUserByProfile(profile);
   if (user_manager->GetPrimaryUser() == user)
     InitRlz(profile);
 
   // TODO(altimofeev): This pointer should probably never be NULL, but it looks
   // like LoginUtilsImpl::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_)
@@ skipping 89 matching lines @@
       ping_delay < 0, base::TimeDelta::FromMilliseconds(abs(ping_delay)));
   if (delegate_)
     delegate_->OnRlzInitialized();
 #endif
 }
 
 void UserSessionManager::InitializeCertsForPrimaryUser(Profile* profile) {
   // Now that the user profile has been initialized
   // |GetNSSCertDatabaseForProfile| is safe to be used.
   UserManager* user_manager = UserManager::Get();
-  const User* primary_user = user_manager->GetPrimaryUser();
+  const user_manager::User* primary_user = user_manager->GetPrimaryUser();
   if (user_manager->IsUserLoggedIn() &&
       primary_user &&
       profile == ProfileHelper::Get()->GetProfileByUser(primary_user) &&
       CertLoader::IsInitialized() &&
       base::SysInfo::IsRunningOnChromeOS()) {
     GetNSSCertDatabaseForProfile(profile,
                                  base::Bind(&OnGetNSSCertDatabaseForUser));
   }
 }
 
@@ skipping 32 matching lines @@
   // Get next user to restore sessions and delete it from list.
   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.
-  UserList logged_in_users = UserManager::Get()->GetLoggedInUsers();
+  user_manager::UserList logged_in_users =
+      UserManager::Get()->GetLoggedInUsers();
   bool user_already_logged_in = false;
-  for (UserList::const_iterator it = logged_in_users.begin();
+  for (user_manager::UserList::const_iterator it = logged_in_users.begin();
        it != logged_in_users.end();
        ++it) {
-    const User* user = (*it);
+    const user_manager::User* user = (*it);
     if (user->email() == user_id) {
       user_already_logged_in = true;
       break;
     }
   }
   DCHECK(!user_already_logged_in);
 
   if (!user_already_logged_in) {
     UserContext user_context(user_id);
     user_context.SetUserIDHash(user_id_hash);
@@ skipping 12 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