Clean up ProfileManager interface.

chrome/browser/profiles/profile_manager.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 "chrome/browser/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 93 matching lines @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #endif
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 namespace {
 
-// Profiles that should be deleted on shutdown.
-std::vector<base::FilePath>& ProfilesToDelete() {
-  CR_DEFINE_STATIC_LOCAL(std::vector<base::FilePath>, profiles_to_delete, ());
-  return profiles_to_delete;
-}
-
 int64 ComputeFilesSize(const base::FilePath& directory,
                        const base::FilePath::StringType& pattern) {
   int64 running_size = 0;
   base::FileEnumerator iter(directory, false, base::FileEnumerator::FILES,
                             pattern);
   while (!iter.Next().empty())
     running_size += iter.GetInfo().GetSize();
   return running_size;
 }
 
@@ skipping 44 matching lines @@
 
   size = ComputeFilesSize(path, FILE_PATH_LITERAL("Policy"));
   size_MB = static_cast<int>(size / kBytesInOneMB);
   UMA_HISTOGRAM_COUNTS_10000("Profile.PolicySize", size_MB);
 
   // Count number of enabled apps in this profile, if we know.
   if (enabled_app_count != -1)
     UMA_HISTOGRAM_COUNTS_10000("Profile.AppCount", enabled_app_count);
 }
 
+// Profiles that should be deleted on shutdown.
+std::vector<base::FilePath>& ProfilesToDelete() {
+  CR_DEFINE_STATIC_LOCAL(std::vector<base::FilePath>, profiles_to_delete, ());
+  return profiles_to_delete;
+}
+
 void QueueProfileDirectoryForDeletion(const base::FilePath& path) {
   ProfilesToDelete().push_back(path);
 }
 
 bool IsProfileMarkedForDeletion(const base::FilePath& profile_path) {
   return std::find(ProfilesToDelete().begin(), ProfilesToDelete().end(),
       profile_path) != ProfilesToDelete().end();
 }
 
 // Physically remove deleted profile directories from disk.
@@ skipping 96 matching lines @@
   for (std::vector<base::FilePath>::iterator it =
           ProfilesToDelete().begin();
        it != ProfilesToDelete().end();
        ++it) {
     NukeProfileFromDisk(*it);
   }
   ProfilesToDelete().clear();
 }
 
 // static
-Profile* ProfileManager::GetLastUsedProfile() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  return profile_manager->GetLastUsedProfile(profile_manager->user_data_dir_);
-}
-
-// static
-Profile* ProfileManager::GetLastUsedProfileAllowedByPolicy() {
-  Profile* profile = GetLastUsedProfile();
-  if (profile->IsGuestSession() ||
-      profile->IsSystemProfile() ||
-      IncognitoModePrefs::GetAvailability(profile->GetPrefs()) ==
-      IncognitoModePrefs::FORCED) {
-    return profile->GetOffTheRecordProfile();
-  }
-  return profile;
-}
-
-// static
-std::vector<Profile*> ProfileManager::GetLastOpenedProfiles() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  return profile_manager->GetLastOpenedProfiles(
-      profile_manager->user_data_dir_);
-}
-
-// static
 Profile* ProfileManager::GetPrimaryUserProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 #if defined(OS_CHROMEOS)
   if (!profile_manager->IsLoggedIn() ||
       !user_manager::UserManager::IsInitialized())
-    return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath(
-        profile_manager->user_data_dir());
+    return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath();
   user_manager::UserManager* manager = user_manager::UserManager::Get();
   // Note: The ProfileHelper will take care of guest profiles.
   return chromeos::ProfileHelper::Get()->GetProfileByUserUnsafe(
       manager->GetPrimaryUser());
 #else
-  return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath(
-      profile_manager->user_data_dir());
+  return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath();
 #endif
 }
 
 // static
 Profile* ProfileManager::GetActiveUserProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 #if defined(OS_CHROMEOS)
   if (!profile_manager)
     return NULL;
 
   if (!profile_manager->IsLoggedIn() ||
       !user_manager::UserManager::IsInitialized()) {
-    return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath(
-        profile_manager->user_data_dir());
+    return profile_manager->GetActiveUserOrOffTheRecordProfileFromPath();
   }
 
   user_manager::UserManager* manager = user_manager::UserManager::Get();
   const user_manager::User* user = manager->GetActiveUser();
   // To avoid an endless loop (crbug.com/334098) we have to additionally check
   // if the profile of the user was already created. If the profile was not yet
   // created we load the profile using the profile directly.
   // TODO: This should be cleaned up with the new profile manager.
   if (user && user->is_profile_created())
     return chromeos::ProfileHelper::Get()->GetProfileByUserUnsafe(user);
 
 #endif
   Profile* profile =
-      profile_manager->GetActiveUserOrOffTheRecordProfileFromPath(
-          profile_manager->user_data_dir());
+      profile_manager->GetActiveUserOrOffTheRecordProfileFromPath();
   // |profile| could be null if the user doesn't have a profile yet and the path
   // is on a read-only volume (preventing Chrome from making a new one).
   // However, most callers of this function immediately dereference the result
   // which would lead to crashes in a variety of call sites. Assert here to
   // figure out how common this is. http://crbug.com/383019
   CHECK(profile) << profile_manager->user_data_dir().AsUTF8Unsafe();
   return profile;
 }
 
 Profile* ProfileManager::GetProfile(const base::FilePath& profile_dir) {
@@ skipping 97 matching lines @@
 #if defined(OS_CHROMEOS)
   if (logged_in_) {
     return chromeos::ProfileHelper::Get()->GetActiveUserProfileDir();
   }
 #endif
   base::FilePath relative_profile_dir;
   // TODO(mirandac): should not automatically be default profile.
   return relative_profile_dir.AppendASCII(chrome::kInitialProfile);
 }
 
-Profile* ProfileManager::GetLastUsedProfile(
-    const base::FilePath& user_data_dir) {
+Profile* ProfileManager::GetLastUsedProfile() {
 #if defined(OS_CHROMEOS)
   // Use default login profile if user has not logged in yet.
-  if (!logged_in_) {
-    return GetActiveUserOrOffTheRecordProfileFromPath(user_data_dir);
-  } else {
-    // CrOS multi-profiles implementation is different so GetLastUsedProfile
-    // has custom implementation too.
-    base::FilePath profile_dir;
-    // In case of multi-profiles we ignore "last used profile" preference
-    // since it may refer to profile that has been in use in previous session.
-    // That profile dir may not be mounted in this session so instead return
-    // active profile from current session.
-    profile_dir = chromeos::ProfileHelper::Get()->GetActiveUserProfileDir();
+  if (!logged_in_)
+    return GetActiveUserOrOffTheRecordProfileFromPath();
 
-    base::FilePath profile_path(user_data_dir);
-    Profile* profile = GetProfile(profile_path.Append(profile_dir));
-    return profile->IsGuestSession() ? profile->GetOffTheRecordProfile() :
-                                       profile;
-  }
+  // CrOS multi-profiles implementation is different so GetLastUsedProfile
+  // has custom implementation too.
+  // In case of multi-profiles we ignore "last used profile" preference
+  // since it may refer to profile that has been in use in previous session.
+  // That profile dir may not be mounted in this session so instead return
+  // active profile from current session.
+  base::FilePath profile_dir =
+      chromeos::ProfileHelper::Get()->GetActiveUserProfileDir();
+
+  Profile* profile = GetProfile(user_data_dir_.Append(profile_dir));
+  return profile->IsGuestSession() ? profile->GetOffTheRecordProfile()
+                                   : profile;
+#else
+  return GetProfile(GetLastUsedProfileDir());
 #endif
-
-  return GetProfile(GetLastUsedProfileDir(user_data_dir));
 }
 
-base::FilePath ProfileManager::GetLastUsedProfileDir(
-    const base::FilePath& user_data_dir) {
-  return user_data_dir.AppendASCII(GetLastUsedProfileName());
+Profile* ProfileManager::GetLastUsedProfileAllowedByPolicy() {
+  Profile* profile = GetLastUsedProfile();
+  if (profile->IsGuestSession() ||
+      profile->IsSystemProfile() ||
+      IncognitoModePrefs::GetAvailability(profile->GetPrefs()) ==
+      IncognitoModePrefs::FORCED) {
+    return profile->GetOffTheRecordProfile();
+  }
+  return profile;
+}
+
+base::FilePath ProfileManager::GetLastUsedProfileDir() {
+  return user_data_dir_.AppendASCII(GetLastUsedProfileName());
 }
 
 std::string ProfileManager::GetLastUsedProfileName() {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
   const std::string last_used_profile_name =
       local_state->GetString(prefs::kProfileLastUsed);
   if (!last_used_profile_name.empty())
     return last_used_profile_name;
 
   return chrome::kInitialProfile;
 }
 
-std::vector<Profile*> ProfileManager::GetLastOpenedProfiles(
-    const base::FilePath& user_data_dir) {
+std::vector<Profile*> ProfileManager::GetLastOpenedProfiles() {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
   std::vector<Profile*> to_return;
   if (local_state->HasPrefPath(prefs::kProfilesLastActive) &&
       local_state->GetList(prefs::kProfilesLastActive)) {
     // Make a copy because the list might change in the calls to GetProfile.
     scoped_ptr<base::ListValue> profile_list(
         local_state->GetList(prefs::kProfilesLastActive)->DeepCopy());
     base::ListValue::const_iterator it;
     std::string profile;
     for (it = profile_list->begin(); it != profile_list->end(); ++it) {
       if (!(*it)->GetAsString(&profile) || profile.empty()) {
         LOG(WARNING) << "Invalid entry in " << prefs::kProfilesLastActive;
         continue;
       }
-      to_return.push_back(GetProfile(user_data_dir.AppendASCII(profile)));
+      to_return.push_back(GetProfile(user_data_dir_.AppendASCII(profile)));
     }
   }
   return to_return;
 }
 
 std::vector<Profile*> ProfileManager::GetLoadedProfiles() const {
   std::vector<Profile*> profiles;
   for (ProfilesInfoMap::const_iterator iter = profiles_info_.begin();
        iter != profiles_info_.end(); ++iter) {
     if (iter->second->created)
@@ skipping 59 matching lines @@
 base::FilePath ProfileManager::GenerateNextProfileDirectoryPath() {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
   DCHECK(profiles::IsMultipleProfilesEnabled());
 
   // Create the next profile in the next available directory slot.
   int next_directory = local_state->GetInteger(prefs::kProfilesNumCreated);
   std::string profile_name = chrome::kMultiProfileDirPrefix;
   profile_name.append(base::IntToString(next_directory));
-  base::FilePath new_path = user_data_dir_;
-#if defined(OS_WIN)
-  new_path = new_path.Append(base::ASCIIToUTF16(profile_name));
-#else
-  new_path = new_path.Append(profile_name);
-#endif
+  base::FilePath new_path = user_data_dir_.AppendASCII(profile_name);
   local_state->SetInteger(prefs::kProfilesNumCreated, ++next_directory);
   return new_path;
 }
 
 ProfileInfoCache& ProfileManager::GetProfileInfoCache() {
   TRACE_EVENT0("browser", "ProfileManager::GetProfileInfoCache");
   if (!profile_info_cache_) {
     profile_info_cache_.reset(new ProfileInfoCache(
         g_browser_process->local_state(), user_data_dir_));
   }
@@ skipping 29 matching lines @@
     // Make sure that this profile is not pending deletion, and is not
     // legacy-supervised.
     if (cur_path != profile_dir &&
         !cache.ProfileIsLegacySupervisedAtIndex(i) &&
         !IsProfileMarkedForDeletion(cur_path)) {
       last_non_supervised_profile_path = cur_path;
       break;
     }
   }
 
-  base::FilePath new_path;
   if (last_non_supervised_profile_path.empty()) {
     // If we are using --new-avatar-menu, then assign the default
     // placeholder avatar and name. Otherwise, use random ones.
-    bool is_new_avatar_menu = switches::IsNewAvatarMenu();
-    int avatar_index = profiles::GetPlaceholderAvatarIndex();
-    base::string16 new_avatar_url = is_new_avatar_menu ?
-        base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(avatar_index)) :
-        base::string16();
-    base::string16 new_profile_name = is_new_avatar_menu ?
-        cache.ChooseNameForNewProfile(avatar_index) : base::string16();
+    base::string16 new_profile_name;
+    base::string16 new_avatar_url;
+    if (switches::IsNewAvatarMenu()) {
+      int avatar_index = profiles::GetPlaceholderAvatarIndex();
+      new_profile_name = cache.ChooseNameForNewProfile(avatar_index);
+      new_avatar_url =
+          base::UTF8ToUTF16(profiles::GetDefaultAvatarIconUrl(avatar_index));
+    }
 
-    new_path = GenerateNextProfileDirectoryPath();
+    base::FilePath new_path = GenerateNextProfileDirectoryPath();
     CreateProfileAsync(new_path,
                        base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                   base::Unretained(this),
                                   profile_dir,
                                   new_path,
                                   callback),
                        new_profile_name,
                        new_avatar_url,
                        std::string());
 
     ProfileMetrics::LogProfileAddNewUser(
         ProfileMetrics::ADD_NEW_USER_LAST_DELETED);
     return;
   }
 
 #if defined(OS_MACOSX)
   // On the Mac, the browser process is not killed when all browser windows are
   // closed, so just in case we are deleting the active profile, and no other
   // profile has been loaded, we must pre-load a next one.
-  const base::FilePath last_used_profile =
-      GetLastUsedProfileDir(user_data_dir_);
+  const base::FilePath last_used_profile = GetLastUsedProfileDir();
   if (last_used_profile == profile_dir ||
       last_used_profile == GetGuestProfilePath()) {
     CreateProfileAsync(last_non_supervised_profile_path,
                        base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                   base::Unretained(this),
                                   profile_dir,
                                   last_non_supervised_profile_path,
                                   callback),
                        base::string16(),
                        base::string16(),
@@ skipping 391 matching lines @@
   return Profile::CreateProfile(path, NULL, Profile::CREATE_MODE_SYNCHRONOUS);
 }
 
 Profile* ProfileManager::CreateProfileAsyncHelper(const base::FilePath& path,
                                                   Delegate* delegate) {
   return Profile::CreateProfile(path,
                                 delegate,
                                 Profile::CREATE_MODE_ASYNCHRONOUS);
 }
 
-Profile* ProfileManager::GetActiveUserOrOffTheRecordProfileFromPath(
-    const base::FilePath& user_data_dir) {
+Profile* ProfileManager::GetActiveUserOrOffTheRecordProfileFromPath() {
 #if defined(OS_CHROMEOS)
-  base::FilePath default_profile_dir(user_data_dir);
   if (!logged_in_) {
-    default_profile_dir = profiles::GetDefaultProfileDir(user_data_dir);
+    base::FilePath default_profile_dir =
+        profiles::GetDefaultProfileDir(user_data_dir_);
     Profile* profile = GetProfile(default_profile_dir);
     // For cros, return the OTR profile so we never accidentally keep
     // user data in an unencrypted profile. But doing this makes
     // many of the browser and ui tests fail. We do return the OTR profile
     // if the login-profile switch is passed so that we can test this.
     if (ShouldGoOffTheRecord(profile))
       return profile->GetOffTheRecordProfile();
     DCHECK(!user_manager::UserManager::Get()->IsLoggedInAsGuest());
     return profile;
   }
 
-  default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
+  base::FilePath default_profile_dir =
+      user_data_dir_.Append(GetInitialProfileDir());
   ProfileInfo* profile_info = GetProfileInfoByPath(default_profile_dir);
   // Fallback to default off-the-record profile, if user profile has not fully
   // loaded yet.
   if (profile_info && !profile_info->created)
-    default_profile_dir = profiles::GetDefaultProfileDir(user_data_dir);
+    default_profile_dir = profiles::GetDefaultProfileDir(user_data_dir_);
 
   Profile* profile = GetProfile(default_profile_dir);
   // Some unit tests didn't initialize the UserManager.
   if (user_manager::UserManager::IsInitialized() &&
       user_manager::UserManager::Get()->IsLoggedInAsGuest())
     return profile->GetOffTheRecordProfile();
   return profile;
 #else
-  base::FilePath default_profile_dir(user_data_dir);
-  default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
+  base::FilePath default_profile_dir =
+      user_data_dir_.Append(GetInitialProfileDir());
   return GetProfile(default_profile_dir);
 #endif
 }
 
 bool ProfileManager::AddProfile(Profile* profile) {
   TRACE_EVENT0("browser", "ProfileManager::AddProfile");
   TRACK_SCOPED_REGION("Startup", "ProfileManager::AddProfile");
 
   DCHECK(profile);
 
@@ skipping 301 matching lines @@
   }
 
   FinishDeletingProfile(profile_to_delete_path, new_active_profile_path);
   if (!original_callback.is_null())
     original_callback.Run(loaded_profile, status);
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }