Sooper experimental refactoring of the profile info cache.

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 944 matching lines @@
   return profile_shortcut_manager_.get();
 }
 
 void ProfileManager::AddProfileToCache(Profile* profile) {
   if (profile->IsGuestSession())
     return;
   ProfileInfoCache& cache = GetProfileInfoCache();
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
-  if (cache.GetIndexOfProfileWithPath(profile->GetPath()) != std::string::npos)
+  // If the profile is already in the cache, there's nothing to do.
+  ProfileInfoEntry entry;
+  if (cache.GetInfoForProfile(profile->GetPath(), &entry))
     return;
 
   string16 username = UTF8ToUTF16(profile->GetPrefs()->GetString(
       prefs::kGoogleServicesUsername));
 
   // Profile name and avatar are set by InitProfileUserPrefs and stored in the
   // profile. Use those values to setup the cache entry.
   string16 profile_name = UTF8ToUTF16(profile->GetPrefs()->GetString(
       prefs::kProfileName));
 
@@ skipping 16 matching lines @@
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   size_t avatar_index;
   std::string profile_name;
   std::string managed_user_id;
   if (profile->IsGuestSession()) {
     profile_name = l10n_util::GetStringUTF8(IDS_PROFILES_GUEST_PROFILE_NAME);
     avatar_index = 0;
   } else {
-    size_t profile_cache_index =
-        cache.GetIndexOfProfileWithPath(profile->GetPath());
+    ProfileInfoEntry entry;
     // If the cache has an entry for this profile, use the cache data.
-    if (profile_cache_index != std::string::npos) {
-      avatar_index =
-          cache.GetAvatarIconIndexOfProfileAtIndex(profile_cache_index);
-      profile_name =
-          UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_cache_index));
-      managed_user_id =
-          cache.GetManagedUserIdOfProfileAtIndex(profile_cache_index);
+    if (cache.GetInfoForProfile(profile->GetPath(), &entry)) {
+      avatar_index = entry.icon_index();
+      profile_name = UTF16ToUTF8(entry.GetDisplayName());
+      managed_user_id = entry.managed_user_id();
     } else if (profile->GetPath() ==
                profiles::GetDefaultProfileDir(cache.GetUserDataDir())) {
       avatar_index = 0;
       profile_name = l10n_util::GetStringUTF8(IDS_DEFAULT_PROFILE_NAME);
     } else {
       avatar_index = cache.ChooseAvatarIconIndexForNewProfile();
       profile_name = UTF16ToUTF8(cache.ChooseNameForNewProfile(avatar_index));
     }
   }
 
@@ skipping 37 matching lines @@
     const CreateCallback& callback) {
   DCHECK(profiles::IsMultipleProfilesEnabled());
   PrefService* local_state = g_browser_process->local_state();
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile_dir.BaseName().MaybeAsASCII() ==
       local_state->GetString(prefs::kProfileLastUsed)) {
     // Update the last used profile pref before closing browser windows. This
     // way the correct last used profile is set for any notification observers.
     base::FilePath last_non_managed_profile_path;
-    for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
-      base::FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
+    const std::vector<ProfileInfoEntry> entries(cache.GetProfilesSortedByName());
+    for (std::vector<ProfileInfoEntry>::const_iterator it = entries.begin();
+        it != entries.end(); ++it) {
+      base::FilePath cur_path = it->path();
       // Make sure that this profile is not pending deletion.
-      if (cur_path != profile_dir && !cache.ProfileIsManagedAtIndex(i) &&
+      if (cur_path != profile_dir && !it->IsManaged() &&
           !IsProfileMarkedForDeletion(cur_path)) {
         last_non_managed_profile_path = cur_path;
         break;
       }
     }
 
     // If we're deleting the last (non-managed) profile, then create a new
     // profile in its place.
     const std::string last_non_managed_profile =
         last_non_managed_profile_path.BaseName().MaybeAsASCII();
@@ skipping 83 matching lines @@
 void ProfileManager::AutoloadProfiles() {
   // If running in the background is disabled for the browser, do not autoload
   // any profiles.
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state->HasPrefPath(prefs::kBackgroundModeEnabled) ||
       !local_state->GetBoolean(prefs::kBackgroundModeEnabled)) {
     return;
   }
 
   ProfileInfoCache& cache = GetProfileInfoCache();
-  size_t number_of_profiles = cache.GetNumberOfProfiles();
-  for (size_t p = 0; p < number_of_profiles; ++p) {
-    if (cache.GetBackgroundStatusOfProfileAtIndex(p)) {
+  const std::vector<ProfileInfoEntry> entries(cache.GetProfilesSortedByName());
+  for (std::vector<ProfileInfoEntry>::const_iterator it = entries.begin();
+      it != entries.end(); ++it) {
+    if (it->is_running_background_apps()) {
       // If status is true, that profile is running background apps. By calling
       // GetProfile, we automatically cause the profile to be loaded which will
       // register it with the BackgroundModeManager.
-      GetProfile(cache.GetPathOfProfileAtIndex(p));
+      GetProfile(it->path());
     }
   }
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }
 
 void ProfileManager::RegisterTestingProfile(Profile* profile,
                                             bool add_to_cache,
@@ skipping 19 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }