[cros] Move User class to user_manager component.

chrome/browser/chromeos/profiles/profile_helper.cc

 // Copyright (c) 2013 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/profiles/profile_helper.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
-#include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/chromeos_switches.h"
+#include "components/user_manager/user.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
 bool ShouldAddProfileDirPrefix(const std::string& user_id_hash) {
   // Do not add profile dir prefix for legacy profile dir and test
   // user profile. The reason of not adding prefix for test user profile
   // is to keep the promise that TestingProfile::kTestUserProfileDir and
   // chrome::kTestUserProfileDir are always in sync. Otherwise,
   // TestingProfile::kTestUserProfileDir needs to be dynamically calculated
   // based on whether multi profile is enabled or not.
   return user_id_hash != chrome::kLegacyProfileDir &&
       user_id_hash != chrome::kTestUserProfileDir;
 }
 
 class UsernameHashMatcher {
  public:
   explicit UsernameHashMatcher(const std::string& h) : username_hash(h) {}
-  bool operator()(const User* user) const {
+  bool operator()(const user_manager::User* user) const {
     return user->username_hash() == username_hash;
   }
 
  private:
   const std::string& username_hash;
 };
 
 }  // anonymous namespace
 
 // static
@@ skipping 93 matching lines @@
              : base::FilePath(user_id_hash);
 }
 
 // static
 base::FilePath ProfileHelper::GetUserProfileDirByUserId(
     const std::string& user_id) {
   // TODO(dpolukhin): Remove Chrome OS specific profile path logic from
   // ProfileManager and use only this function to construct profile path.
   // TODO(nkostylev): Cleanup profile dir related code paths crbug.com/294233
   base::FilePath profile_dir;
-  const User* user = UserManager::Get()->FindUser(user_id);
+  const user_manager::User* user = UserManager::Get()->FindUser(user_id);
   if (user && !user->username_hash().empty())
     profile_dir = ProfileHelper::GetUserProfileDir(user->username_hash());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   profile_dir = profile_manager->user_data_dir().Append(profile_dir);
 
   return profile_dir;
 }
 
 // static
 bool ProfileHelper::IsSigninProfile(Profile* profile) {
   return profile->GetPath().BaseName().value() == chrome::kInitialProfile;
 }
 
 // static
 bool ProfileHelper::IsOwnerProfile(Profile* profile) {
   if (!profile)
     return false;
-  chromeos::User* user = ProfileHelper::Get()->GetUserByProfile(profile);
+  user_manager::User* user = ProfileHelper::Get()->GetUserByProfile(profile);
   if (!user)
     return false;
 
   return user->email() == chromeos::UserManager::Get()->GetOwnerEmail();
 }
 
 void ProfileHelper::ProfileStartup(Profile* profile, bool process_startup) {
   // Initialize Chrome OS preferences like touch pad sensitivity. For the
   // preferences to work in the guest mode, the initialization has to be
   // done after |profile| is switched to the incognito profile (which
@@ skipping 33 matching lines @@
     return;
   }
   signin_profile_clear_requested_ = true;
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(GetSigninProfile());
   remover->AddObserver(this);
   remover->Remove(BrowsingDataRemover::REMOVE_SITE_DATA,
                   BrowsingDataHelper::ALL);
 }
 
-Profile* ProfileHelper::GetProfileByUser(const User* user) {
+Profile* ProfileHelper::GetProfileByUser(const user_manager::User* user) {
   // This map is non-empty only in tests.
   if (!user_to_profile_for_testing_.empty()) {
-    std::map<const User*, Profile*>::const_iterator it =
+    std::map<const user_manager::User*, Profile*>::const_iterator it =
         user_to_profile_for_testing_.find(user);
     return it == user_to_profile_for_testing_.end() ? NULL : it->second;
   }
 
   Profile* profile = NULL;
   if (user->is_profile_created())
     profile = ProfileHelper::GetProfileByUserIdHash(user->username_hash());
   else
     profile = ProfileManager::GetActiveUserProfile();
 
   // GetActiveUserProfile() or GetProfileByUserIdHash() returns a new instance
   // of ProfileImpl(), but actually its OffTheRecordProfile() should be used.
   if (profile && UserManager::Get()->IsLoggedInAsGuest())
     profile = profile->GetOffTheRecordProfile();
   return profile;
 }
 
-User* ProfileHelper::GetUserByProfile(Profile* profile) {
+user_manager::User* ProfileHelper::GetUserByProfile(Profile* profile) {
   // This map is non-empty only in tests.
   if (enable_profile_to_user_testing || !user_list_for_testing_.empty()) {
     if (always_return_primary_user_for_testing)
-      return const_cast<User*>(UserManager::Get()->GetPrimaryUser());
+      return const_cast<user_manager::User*>(
+          UserManager::Get()->GetPrimaryUser());
 
     const std::string& user_name = profile->GetProfileName();
-    for (UserList::const_iterator it = user_list_for_testing_.begin();
+    for (user_manager::UserList::const_iterator it =
+             user_list_for_testing_.begin();
          it != user_list_for_testing_.end();
          ++it) {
       if ((*it)->email() == user_name)
         return *it;
     }
 
     // In case of test setup we should always default to primary user.
-    return const_cast<User*>(UserManager::Get()->GetPrimaryUser());
+    return const_cast<user_manager::User*>(
+        UserManager::Get()->GetPrimaryUser());
   }
 
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (ProfileHelper::IsSigninProfile(profile))
     return NULL;
 
   UserManager* user_manager = UserManager::Get();
 
   // Special case for non-CrOS tests that do create several profiles
   // and don't really care about mapping to the real user.
   // Without multi-profiles on Chrome OS such tests always got active_user_.
   // Now these tests will specify special flag to continue working.
   // In future those tests can get a proper CrOS configuration i.e. register
   // and login several users if they want to work with an additional profile.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kIgnoreUserProfileMappingForTests)) {
     return user_manager->GetActiveUser();
   }
 
   const std::string username_hash =
       ProfileHelper::GetUserIdHashFromProfile(profile);
-  const UserList& users = user_manager->GetUsers();
-  const UserList::const_iterator pos = std::find_if(
+  const user_manager::UserList& users = user_manager->GetUsers();
+  const user_manager::UserList::const_iterator pos = std::find_if(
       users.begin(), users.end(), UsernameHashMatcher(username_hash));
   if (pos != users.end())
     return *pos;
 
   // Many tests do not have their users registered with UserManager and
   // runs here. If |active_user_| matches |profile|, returns it.
-  const User* active_user = user_manager->GetActiveUser();
+  const user_manager::User* active_user = user_manager->GetActiveUser();
   return active_user &&
                  ProfileHelper::GetProfilePathByUserIdHash(
                      active_user->username_hash()) == profile->GetPath()
-             ? const_cast<User*>(active_user)
+             ? const_cast<user_manager::User*>(active_user)
              : NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileHelper, BrowsingDataRemover::Observer implementation:
 
 void ProfileHelper::OnBrowsingDataRemoverDone() {
   signin_profile_clear_requested_ = false;
   for (size_t i = 0; i < on_clear_callbacks_.size(); ++i) {
     if (!on_clear_callbacks_[i].is_null())
@@ skipping 21 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileHelper, UserManager::UserSessionStateObserver implementation:
 
 void ProfileHelper::ActiveUserHashChanged(const std::string& hash) {
   active_user_id_hash_ = hash;
   base::FilePath profile_path = GetProfilePathByUserIdHash(hash);
   VLOG(1) << "Switching to profile path: " << profile_path.value();
 }
 
-void ProfileHelper::SetProfileToUserMappingForTesting(User* user) {
+void ProfileHelper::SetProfileToUserMappingForTesting(
+    user_manager::User* user) {
   user_list_for_testing_.push_back(user);
 }
 
 // static
 void ProfileHelper::SetProfileToUserForTestingEnabled(bool enabled) {
   enable_profile_to_user_testing = enabled;
 }
 
 // static
 void ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(bool value) {
   always_return_primary_user_for_testing = true;
   ProfileHelper::SetProfileToUserForTestingEnabled(true);
 }
 
-void ProfileHelper::SetUserToProfileMappingForTesting(const User* user,
-                                                      Profile* profile) {
+void ProfileHelper::SetUserToProfileMappingForTesting(
+    const user_manager::User* user,
+    Profile* profile) {
   user_to_profile_for_testing_[user] = profile;
 }
 
 }  // namespace chromeos