Refactor ProfileInfoCache in c/b/profiles

chrome/browser/profiles/profile_manager_unittest.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 <stddef.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 146 matching lines @@
                           MockObserver* mock_observer) {
     manager->CreateProfileAsync(
         temp_dir_.path().AppendASCII(name),
         base::Bind(&MockObserver::OnProfileCreated,
                    base::Unretained(mock_observer)),
         base::UTF8ToUTF16(name),
         profiles::GetDefaultAvatarIconUrl(0),
         is_supervised ? "Dummy ID" : std::string());
   }
 
-  // Helper function to add a profile with |profile_name| to
-  // |profile_manager|'s ProfileInfoCache, and return the profile created.
-  Profile* AddProfileToCache(ProfileManager* profile_manager,
-                             const std::string& path_suffix,
-                             const base::string16& profile_name) {
-    ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-    size_t num_profiles = cache.GetNumberOfProfiles();
+  // Helper function to add a profile with |profile_name| to |profile_manager|'s
+  // ProfileAttributesStorage, and return the profile created.
+  Profile* AddProfileToStorage(ProfileManager* profile_manager,
+                               const std::string& path_suffix,
+                               const base::string16& profile_name) {
+    ProfileAttributesStorage& storage =
+        profile_manager->GetProfileAttributesStorage();
+    size_t num_profiles = storage.GetNumberOfProfiles();
     base::FilePath path = temp_dir_.path().AppendASCII(path_suffix);
-    cache.AddProfileToCache(path, profile_name,
-                            std::string(), base::string16(), 0, std::string());
-    EXPECT_EQ(num_profiles + 1, cache.GetNumberOfProfiles());
+    storage.AddProfile(path, profile_name, std::string(), base::string16(), 0,
+                       std::string());
+    EXPECT_EQ(num_profiles + 1u, storage.GetNumberOfProfiles());
     return profile_manager->GetProfile(path);
   }
 
 #if defined(OS_CHROMEOS)
   // Helper function to register an user with id |user_id| and create profile
   // with a correct path.
   void RegisterUser(const std::string& user_id) {
     chromeos::ProfileHelper* profile_helper = chromeos::ProfileHelper::Get();
     const std::string user_id_hash =
         profile_helper->GetUserIdHashByUserIdForTesting(user_id);
@@ skipping 220 matching lines @@
 }
 
 TEST_F(ProfileManagerTest, CreateProfileAsyncCheckOmitted) {
   std::string name = "0 Supervised Profile";
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   CreateProfileAsync(profile_manager, name, true, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(1u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
   // Supervised profiles should start out omitted from the profile list.
-  EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
+  EXPECT_TRUE(storage.GetAllProfilesAttributesSortedByName()[0u]->IsOmitted());
 
   name = "1 Regular Profile";
   CreateProfileAsync(profile_manager, name, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(2u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(2u, storage.GetNumberOfProfiles());
   // Non-supervised profiles should be included in the profile list.
-  EXPECT_FALSE(cache.IsOmittedProfileAtIndex(1));
+  EXPECT_FALSE(storage.GetAllProfilesAttributesSortedByName()[1u]->IsOmitted());
 }
 
-TEST_F(ProfileManagerTest, AddProfileToCacheCheckOmitted) {
+TEST_F(ProfileManagerTest, AddProfileToStorageCheckOmitted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   const base::FilePath supervised_path =
       temp_dir_.path().AppendASCII("Supervised");
   TestingProfile* supervised_profile =
       new TestingProfile(supervised_path, NULL);
   supervised_profile->GetPrefs()->SetString(prefs::kSupervisedUserId, "An ID");
 
   // RegisterTestingProfile adds the profile to the cache and takes ownership.
   profile_manager->RegisterTestingProfile(supervised_profile, true, false);
-  EXPECT_EQ(1u, cache.GetNumberOfProfiles());
-  EXPECT_TRUE(cache.IsOmittedProfileAtIndex(0));
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
+  EXPECT_TRUE(storage.GetAllProfilesAttributesSortedByName()[0u]->IsOmitted());
 
   const base::FilePath nonsupervised_path = temp_dir_.path().AppendASCII(
       "Non-Supervised");
   TestingProfile* nonsupervised_profile = new TestingProfile(nonsupervised_path,
                                                              NULL);
   profile_manager->RegisterTestingProfile(nonsupervised_profile, true, false);
 
-  EXPECT_EQ(2u, cache.GetNumberOfProfiles());
-  size_t supervised_index = cache.GetIndexOfProfileWithPath(supervised_path);
-  EXPECT_TRUE(cache.IsOmittedProfileAtIndex(supervised_index));
-  size_t nonsupervised_index =
-      cache.GetIndexOfProfileWithPath(nonsupervised_path);
-  EXPECT_FALSE(cache.IsOmittedProfileAtIndex(nonsupervised_index));
+  EXPECT_EQ(2u, storage.GetNumberOfProfiles());
+  ProfileAttributesEntry* entry;
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(supervised_path, &entry));
+  EXPECT_TRUE(entry->IsOmitted());
+
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(nonsupervised_path, &entry));
+  EXPECT_FALSE(entry->IsOmitted());
 }
 
 TEST_F(ProfileManagerTest, GetGuestProfilePath) {
   base::FilePath guest_path = ProfileManager::GetGuestProfilePath();
   base::FilePath expected_path = temp_dir_.path();
   expected_path = expected_path.Append(chrome::kGuestProfileDir);
   EXPECT_EQ(expected_path, guest_path);
 }
 
 TEST_F(ProfileManagerTest, GetSystemProfilePath) {
@@ skipping 62 matching lines @@
 
   Profile* last_used_profile = ProfileManager::GetLastUsedProfile();
   EXPECT_TRUE(last_used_profile->IsOffTheRecord());
 
   EXPECT_TRUE(last_used_profile->IsSameProfile(active_profile));
 }
 #endif
 
 TEST_F(ProfileManagerTest, AutoloadProfilesWithBackgroundApps) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
   local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
                                   new base::FundamentalValue(true));
 
   // Setting a pref which is not applicable to a system (i.e., Android in this
   // case) does not necessarily create it. Don't bother continuing with the
   // test if this pref doesn't exist because it will not load the profiles if
   // it cannot verify that the pref for background mode is enabled.
   if (!local_state_.Get()->HasPrefPath(prefs::kBackgroundModeEnabled))
     return;
 
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
-  cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
-                          ASCIIToUTF16("name_1"), "12345", base::string16(), 0,
-                          std::string());
-  cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
-                          ASCIIToUTF16("name_2"), "23456", base::string16(), 0,
-                          std::string());
-  cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_3"),
-                          ASCIIToUTF16("name_3"), "34567", base::string16(), 0,
-                          std::string());
-  cache.SetBackgroundStatusOfProfileAtIndex(0, true);
-  cache.SetBackgroundStatusOfProfileAtIndex(2, true);
-  EXPECT_EQ(3u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
+
+  storage.AddProfile(profile_manager->user_data_dir().AppendASCII("path_1"),
+      ASCIIToUTF16("name_1"), "12345", base::string16(), 0, std::string());
+  storage.AddProfile(profile_manager->user_data_dir().AppendASCII("path_2"),
+      ASCIIToUTF16("name_2"), "23456", base::string16(), 0, std::string());
+  storage.AddProfile(profile_manager->user_data_dir().AppendASCII("path_3"),
+      ASCIIToUTF16("name_3"), "34567", base::string16(), 0, std::string());
+
+  EXPECT_EQ(3u, storage.GetNumberOfProfiles());
+
+  std::vector<ProfileAttributesEntry*> entries =
+      storage.GetAllProfilesAttributes();
+  entries[0u]->SetBackgroundStatus(true);
+  entries[2u]->SetBackgroundStatus(true);
 
   profile_manager->AutoloadProfiles();
 
   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
 }
 
 TEST_F(ProfileManagerTest, DoNotAutoloadProfilesIfBackgroundModeOff) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
   local_state_.Get()->SetUserPref(prefs::kBackgroundModeEnabled,
                                   new base::FundamentalValue(false));
 
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
-  cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_1"),
-                          ASCIIToUTF16("name_1"), "12345", base::string16(), 0,
-                          std::string());
-  cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_2"),
-                          ASCIIToUTF16("name_2"), "23456", base::string16(), 0,
-                          std::string());
-  cache.SetBackgroundStatusOfProfileAtIndex(0, false);
-  cache.SetBackgroundStatusOfProfileAtIndex(1, true);
-  EXPECT_EQ(2u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
+
+  storage.AddProfile(profile_manager->user_data_dir().AppendASCII("path_1"),
+      ASCIIToUTF16("name_1"), "12345", base::string16(), 0, std::string());
+  storage.AddProfile(profile_manager->user_data_dir().AppendASCII("path_2"),
+      ASCIIToUTF16("name_2"), "23456", base::string16(), 0, std::string());
+
+  EXPECT_EQ(2u, storage.GetNumberOfProfiles());
+
+  std::vector<ProfileAttributesEntry*> entries =
+      storage.GetAllProfilesAttributes();
+  entries[0u]->SetBackgroundStatus(false);
+  entries[1u]->SetBackgroundStatus(true);
 
   profile_manager->AutoloadProfiles();
 
   EXPECT_EQ(0u, profile_manager->GetLoadedProfiles().size());
 }
 
 TEST_F(ProfileManagerTest, InitProfileUserPrefs) {
   base::FilePath dest_path = temp_dir_.path();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 
@@ skipping 17 matching lines @@
       avatar_index));
 }
 
 // Tests that a new profile's entry in the profile info cache is setup with the
 // same values that are in the profile prefs.
 TEST_F(ProfileManagerTest, InitProfileInfoCacheForAProfile) {
   base::FilePath dest_path = temp_dir_.path();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 
   // Successfully create the profile
   Profile* profile = profile_manager->GetProfile(dest_path);
   ASSERT_TRUE(profile);
 
   std::string profile_name =
       profile->GetPrefs()->GetString(prefs::kProfileName);
   size_t avatar_index =
       profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
 
-  size_t profile_index = cache.GetIndexOfProfileWithPath(dest_path);
+  ProfileAttributesEntry* entry;
+  ASSERT_TRUE(profile_manager->GetProfileAttributesStorage().
+                  GetProfileAttributesWithPath(dest_path, &entry));
 
   // Check if the profile prefs are the same as the cache prefs
-  EXPECT_EQ(profile_name,
-            base::UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_index)));
-  EXPECT_EQ(avatar_index,
-            cache.GetAvatarIconIndexOfProfileAtIndex(profile_index));
+  EXPECT_EQ(profile_name, base::UTF16ToUTF8(entry->GetName()));
+  EXPECT_EQ(avatar_index, entry->GetAvatarIconIndex());
 }
 
 TEST_F(ProfileManagerTest, GetLastUsedProfileAllowedByPolicy) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
 #if defined(OS_CHROMEOS)
   // On CrOS, profile returned by GetLastUsedProfile is a singin profile that
   // is forced to be incognito. That's why we need to create at least one user
   // to get a regular profile.
@@ skipping 291 matching lines @@
   browser3.reset();
 
   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(1U, last_opened_profiles.size());
   EXPECT_EQ(normal_profile, last_opened_profiles[0]);
 }
 
 TEST_F(ProfileManagerTest, CleanUpEphemeralProfiles) {
   // Create two profiles, one of them ephemeral.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  ASSERT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  ASSERT_EQ(0u, storage.GetNumberOfProfiles());
 
   const std::string profile_name1 = "Homer";
-  base::FilePath path1 = temp_dir_.path().AppendASCII(profile_name1);
-  cache.AddProfileToCache(path1, base::UTF8ToUTF16(profile_name1),
-                          std::string(), base::UTF8ToUTF16(profile_name1), 0,
-                          std::string());
-  cache.SetProfileIsEphemeralAtIndex(0, true);
+  base::FilePath path1 =
+      profile_manager->user_data_dir().AppendASCII(profile_name1);
+  storage.AddProfile(path1, base::UTF8ToUTF16(profile_name1), std::string(),
+                     base::UTF8ToUTF16(profile_name1), 0, std::string());
+  storage.GetAllProfilesAttributes()[0u]->SetIsEphemeral(true);
   ASSERT_TRUE(base::CreateDirectory(path1));
 
   const std::string profile_name2 = "Marge";
-  base::FilePath path2 = temp_dir_.path().AppendASCII(profile_name2);
-  cache.AddProfileToCache(path2, base::UTF8ToUTF16(profile_name2),
-                          std::string(), base::UTF8ToUTF16(profile_name2), 0,
-                          std::string());
-  ASSERT_EQ(2u, cache.GetNumberOfProfiles());
+  base::FilePath path2 =
+      profile_manager->user_data_dir().AppendASCII(profile_name2);
+  storage.AddProfile(path2, base::UTF8ToUTF16(profile_name2), std::string(),
+                     base::UTF8ToUTF16(profile_name2), 0, std::string());
+  ASSERT_EQ(2u, storage.GetNumberOfProfiles());
   ASSERT_TRUE(base::CreateDirectory(path2));
 
   // Set the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 
   profile_manager->CleanUpEphemeralProfiles();
   base::RunLoop().RunUntilIdle();
 
   // The ephemeral profile should be deleted, and the last used profile set to
   // the other one.
   EXPECT_FALSE(base::DirectoryExists(path1));
   EXPECT_TRUE(base::DirectoryExists(path2));
   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
-  ASSERT_EQ(1u, cache.GetNumberOfProfiles());
+  ASSERT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Mark the remaining profile ephemeral and clean up.
-  cache.SetProfileIsEphemeralAtIndex(0, true);
+  storage.GetAllProfilesAttributes()[0u]->SetIsEphemeral(true);
   profile_manager->CleanUpEphemeralProfiles();
   base::RunLoop().RunUntilIdle();
 
   // The profile should be deleted, and the last used profile set to a new one.
   EXPECT_FALSE(base::DirectoryExists(path2));
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
   EXPECT_EQ("Profile 1", local_state->GetString(prefs::kProfileLastUsed));
 }
 
 TEST_F(ProfileManagerTest, ActiveProfileDeleted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
   // Create and load two profiles.
   const std::string profile_name1 = "New Profile 1";
   const std::string profile_name2 = "New Profile 2";
   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   CreateProfileAsync(profile_manager, profile_name2, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(2u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
+  EXPECT_EQ(2u, profile_manager->GetProfileAttributesStorage().
+                    GetNumberOfProfiles());
 
   // Set the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 
   // Delete the active profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
 }
 
 TEST_F(ProfileManagerTest, LastProfileDeleted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
 
   // Create and load a profile.
   const std::string profile_name1 = "New Profile 1";
   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(1));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Set it as the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 
   // Delete the active profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   // A new profile should have been created
   const std::string profile_name2 = "Profile 1";
   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 
   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
-  EXPECT_EQ(dest_path2,
-      profile_manager->GetProfileInfoCache().GetPathOfProfileAtIndex(0));
+  EXPECT_EQ(dest_path2, storage.GetAllProfilesAttributes()[0u]->GetPath());
 }
 
 TEST_F(ProfileManagerTest, LastProfileDeletedWithGuestActiveProfile) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
 
   // Create and load a profile.
   const std::string profile_name1 = "New Profile 1";
   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Create the profile and register it.
   const std::string guest_profile_name =
       ProfileManager::GetGuestProfilePath().BaseName().MaybeAsASCII();
 
   TestingProfile::Builder builder;
   builder.SetGuestSession();
   builder.SetPath(ProfileManager::GetGuestProfilePath());
   TestingProfile* guest_profile = builder.Build().release();
   guest_profile->set_profile_name(guest_profile_name);
   // Registering the profile passes ownership to the ProfileManager.
   profile_manager->RegisterTestingProfile(guest_profile, false, false);
 
-  // The Guest profile does not get added to the ProfileInfoCache.
+  // The Guest profile does not get added to the ProfileAttributesStorage.
   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Set the Guest profile as the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed, guest_profile_name);
 
   // Delete the other profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   // A new profile should have been created.
   const std::string profile_name2 = "Profile 1";
   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 
   EXPECT_EQ(3u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(1u, profile_manager->GetProfileInfoCache().GetNumberOfProfiles());
-  EXPECT_EQ(dest_path2,
-      profile_manager->GetProfileInfoCache().GetPathOfProfileAtIndex(0));
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
+  EXPECT_EQ(dest_path2, storage.GetAllProfilesAttributes()[0u]->GetPath());
 }
 
 TEST_F(ProfileManagerTest, ProfileDisplayNameResetsDefaultName) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
   const base::string16 default_profile_name =
       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
-  const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
-  Profile* profile1 = AddProfileToCache(profile_manager,
-                                        "path_1", profile_name1);
+  const base::string16 profile_name1 = storage.ChooseNameForNewProfile(0u);
+  Profile* profile1 = AddProfileToStorage(profile_manager,
+                                          "path_1", profile_name1);
   EXPECT_EQ(default_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 
   // Multiple profiles means displaying the actual profile names.
-  const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
-  Profile* profile2 = AddProfileToCache(profile_manager,
-                                        "path_2", profile_name2);
+  const base::string16 profile_name2 = storage.ChooseNameForNewProfile(1u);
+  Profile* profile2 = AddProfileToStorage(profile_manager,
+                                          "path_2", profile_name2);
   EXPECT_EQ(profile_name1,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
   EXPECT_EQ(profile_name2,
             profiles::GetAvatarNameForProfile(profile2->GetPath()));
 
   // Deleting a profile means returning to the default name.
   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(default_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 }
 
 TEST_F(ProfileManagerTest, ProfileDisplayNamePreservesCustomName) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
   const base::string16 default_profile_name =
       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
-  const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
-  Profile* profile1 = AddProfileToCache(profile_manager,
-                                        "path_1", profile_name1);
+  const base::string16 profile_name1 = storage.ChooseNameForNewProfile(0u);
+  Profile* profile1 = AddProfileToStorage(profile_manager,
+                                          "path_1", profile_name1);
   EXPECT_EQ(default_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
+  ASSERT_EQ(1u, storage.GetNumberOfProfiles());
 
   // We should display custom names for local profiles.
   const base::string16 custom_profile_name = ASCIIToUTF16("Batman");
-  cache.SetNameOfProfileAtIndex(0, custom_profile_name);
-  cache.SetProfileIsUsingDefaultNameAtIndex(0, false);
-  EXPECT_EQ(custom_profile_name, cache.GetNameOfProfileAtIndex(0));
+  ProfileAttributesEntry* entry = storage.GetAllProfilesAttributes()[0u];
+  entry->SetName(custom_profile_name);
+  entry->SetIsUsingDefaultName(false);
+  EXPECT_EQ(custom_profile_name, entry->GetName());
   EXPECT_EQ(custom_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 
   // Multiple profiles means displaying the actual profile names.
-  const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
-  Profile* profile2 = AddProfileToCache(profile_manager,
-                                        "path_2", profile_name2);
+  const base::string16 profile_name2 = storage.ChooseNameForNewProfile(1u);
+  Profile* profile2 = AddProfileToStorage(profile_manager,
+                                          "path_2", profile_name2);
   EXPECT_EQ(custom_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
   EXPECT_EQ(profile_name2,
             profiles::GetAvatarNameForProfile(profile2->GetPath()));
 
   // Deleting a profile means returning to the original, custom name.
   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(custom_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 }
 
 TEST_F(ProfileManagerTest, ProfileDisplayNamePreservesSignedInName) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   // Only one local profile means we display IDS_SINGLE_PROFILE_DISPLAY_NAME.
   const base::string16 default_profile_name =
       l10n_util::GetStringUTF16(IDS_SINGLE_PROFILE_DISPLAY_NAME);
-  const base::string16 profile_name1 = cache.ChooseNameForNewProfile(0);
-  Profile* profile1 = AddProfileToCache(profile_manager,
-                                        "path_1", profile_name1);
+  const base::string16 profile_name1 = storage.ChooseNameForNewProfile(0u);
+  Profile* profile1 = AddProfileToStorage(profile_manager,
+                                          "path_1", profile_name1);
   EXPECT_EQ(default_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 
+  ProfileAttributesEntry* entry = storage.GetAllProfilesAttributes()[0u];
   // For a signed in profile with a default name we still display
   // IDS_SINGLE_PROFILE_DISPLAY_NAME.
-  cache.SetAuthInfoOfProfileAtIndex(0, "12345", ASCIIToUTF16("user@gmail.com"));
-  EXPECT_EQ(profile_name1, cache.GetNameOfProfileAtIndex(0));
+  entry->SetAuthInfo("12345", ASCIIToUTF16("user@gmail.com"));
+  EXPECT_EQ(profile_name1, entry->GetName());
   EXPECT_EQ(default_profile_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 
   // For a signed in profile with a non-default Gaia given name we display the
   // Gaia given name.
-  cache.SetAuthInfoOfProfileAtIndex(0, "12345", ASCIIToUTF16("user@gmail.com"));
+  entry->SetAuthInfo("12345", ASCIIToUTF16("user@gmail.com"));
   const base::string16 gaia_given_name(ASCIIToUTF16("given name"));
-  cache.SetGAIAGivenNameOfProfileAtIndex(0, gaia_given_name);
-  EXPECT_EQ(gaia_given_name, cache.GetNameOfProfileAtIndex(0));
+  entry->SetGAIAGivenName(gaia_given_name);
+  EXPECT_EQ(gaia_given_name, entry->GetName());
   EXPECT_EQ(gaia_given_name,
       profiles::GetAvatarNameForProfile(profile1->GetPath()));
 
   // Multiple profiles means displaying the actual profile names.
-  const base::string16 profile_name2 = cache.ChooseNameForNewProfile(1);
-  Profile* profile2 = AddProfileToCache(profile_manager,
-                                        "path_2", profile_name2);
+  const base::string16 profile_name2 = storage.ChooseNameForNewProfile(1u);
+  Profile* profile2 = AddProfileToStorage(profile_manager,
+                                          "path_2", profile_name2);
   EXPECT_EQ(gaia_given_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
   EXPECT_EQ(profile_name2,
             profiles::GetAvatarNameForProfile(profile2->GetPath()));
 
   // Deleting a profile means returning to the original, actual profile name.
   profile_manager->ScheduleProfileForDeletion(profile2->GetPath(),
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(gaia_given_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 }
 
 TEST_F(ProfileManagerTest, ProfileDisplayNameIsEmailIfDefaultName) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  EXPECT_EQ(0u, cache.GetNumberOfProfiles());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   // Create two signed in profiles, with both new and legacy default names, and
   // a profile with a custom name.
-  Profile* profile1 = AddProfileToCache(
-      profile_manager, "path_1", ASCIIToUTF16("Person 1"));
-  Profile* profile2 = AddProfileToCache(
-      profile_manager, "path_2", ASCIIToUTF16("Default Profile"));
+  Profile* profile1 = AddProfileToStorage(profile_manager, "path_1",
+                                          ASCIIToUTF16("Person 1"));
+  Profile* profile2 = AddProfileToStorage(profile_manager, "path_2",
+                                          ASCIIToUTF16("Default Profile"));
   const base::string16 profile_name3(ASCIIToUTF16("Batman"));
-  Profile* profile3 = AddProfileToCache(
-      profile_manager, "path_3", profile_name3);
-  EXPECT_EQ(3u, cache.GetNumberOfProfiles());
+  Profile* profile3 = AddProfileToStorage(profile_manager, "path_3",
+                                          profile_name3);
+  EXPECT_EQ(3u, storage.GetNumberOfProfiles());
 
   // Sign in all profiles, and make sure they do not have a Gaia name set.
   const base::string16 email1(ASCIIToUTF16("user1@gmail.com"));
   const base::string16 email2(ASCIIToUTF16("user2@gmail.com"));
   const base::string16 email3(ASCIIToUTF16("user3@gmail.com"));
 
-  int index = cache.GetIndexOfProfileWithPath(profile1->GetPath());
-  cache.SetAuthInfoOfProfileAtIndex(index, "12345", email1);
-  cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
-  cache.SetGAIANameOfProfileAtIndex(index, base::string16());
+  ProfileAttributesEntry* entry;
+
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(profile1->GetPath(),
+                                                   &entry));
+  entry->SetAuthInfo("12345", email1);
+  entry->SetGAIAGivenName(base::string16());
+  entry->SetGAIAName(base::string16());
 
   // This may resort the cache, so be extra cautious to use the right profile.
-  index = cache.GetIndexOfProfileWithPath(profile2->GetPath());
-  cache.SetAuthInfoOfProfileAtIndex(index, "23456", email2);
-  cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
-  cache.SetGAIANameOfProfileAtIndex(index, base::string16());
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(profile2->GetPath(),
+                                                   &entry));
+  entry->SetAuthInfo("23456", email2);
+  entry->SetGAIAGivenName(base::string16());
+  entry->SetGAIAName(base::string16());
 
-  index = cache.GetIndexOfProfileWithPath(profile3->GetPath());
-  cache.SetAuthInfoOfProfileAtIndex(index, "34567", email3);
-  cache.SetGAIAGivenNameOfProfileAtIndex(index, base::string16());
-  cache.SetGAIANameOfProfileAtIndex(index, base::string16());
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(profile3->GetPath(),
+                                                   &entry));
+  entry->SetAuthInfo("34567", email3);
+  entry->SetGAIAGivenName(base::string16());
+  entry->SetGAIAName(base::string16());
 
   // The profiles with default names should display the email address.
   EXPECT_EQ(email1, profiles::GetAvatarNameForProfile(profile1->GetPath()));
   EXPECT_EQ(email2, profiles::GetAvatarNameForProfile(profile2->GetPath()));
 
   // The profile with the custom name should display that.
   EXPECT_EQ(profile_name3,
             profiles::GetAvatarNameForProfile(profile3->GetPath()));
 
   // Adding a Gaia name to a profile that previously had a default name should
   // start displaying it.
   const base::string16 gaia_given_name(ASCIIToUTF16("Robin"));
-  cache.SetGAIAGivenNameOfProfileAtIndex(
-      cache.GetIndexOfProfileWithPath(profile1->GetPath()), gaia_given_name);
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(profile1->GetPath(),
+                                                   &entry));
+  entry->SetGAIAGivenName(gaia_given_name);
   EXPECT_EQ(gaia_given_name,
             profiles::GetAvatarNameForProfile(profile1->GetPath()));
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 
 #if defined(OS_MACOSX)
 // These tests are for a Mac-only code path that assumes the browser
 // process isn't killed when all browser windows are closed.
 TEST_F(ProfileManagerTest, ActiveProfileDeletedNeedsToLoadNextProfile) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
   // Create and load one profile, and just create a second profile.
   const std::string profile_name1 = "New Profile 1";
   const std::string profile_name2 = "New Profile 2";
   base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   // Track the profile, but don't load it.
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2), "23456",
-                          base::string16(), 0, std::string());
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  storage.AddProfile(dest_path2, ASCIIToUTF16(profile_name2), "23456",
+                     base::string16(), 0, std::string());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(2u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(2u, storage.GetNumberOfProfiles());
 
   // Set the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed,
                          dest_path1.BaseName().MaybeAsASCII());
 
   // Delete the active profile. This should switch and load the unloaded
   // profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
@@ skipping 21 matching lines @@
   base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
   base::FilePath dest_path3 = temp_dir_.path().AppendASCII(profile_name3);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   // Create the other profiles, but don't load them. Assign a fake avatar icon
-  // to ensure that profiles in the info cache are sorted by the profile name,
-  // and not randomly by the avatar name.
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  cache.AddProfileToCache(dest_path2, ASCIIToUTF16(profile_name2),
-                          "23456", ASCIIToUTF16(profile_name2), 1,
-                          std::string());
-  cache.AddProfileToCache(dest_path3, ASCIIToUTF16(profile_name3),
-                          "34567", ASCIIToUTF16(profile_name3), 2,
-                          std::string());
+  // to ensure that profiles in the profile attributes storage are sorted by the
+  // profile name, and not randomly by the avatar name.
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
+  storage.AddProfile(dest_path2, ASCIIToUTF16(profile_name2), "23456",
+                     ASCIIToUTF16(profile_name2), 1, std::string());
+  storage.AddProfile(dest_path3, ASCIIToUTF16(profile_name3), "34567",
+                     ASCIIToUTF16(profile_name3), 2, std::string());
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
-  EXPECT_EQ(3u, cache.GetNumberOfProfiles());
+  EXPECT_EQ(3u, storage.GetNumberOfProfiles());
 
   // Set the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed,
                          dest_path1.BaseName().MaybeAsASCII());
 
   // Delete the active profile, Profile1.
   // This will post a CreateProfileAsync message, that tries to load Profile2,
   // which checks that the profile is not being deleted, and then calls back
   // FinishDeletingProfile for Profile1.
   // Try to break this flow by setting the active profile to Profile2 in the
   // middle (so after the first posted message), and trying to delete Profile2,
   // so that the ProfileManager has to look for a different profile to load.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   local_state->SetString(prefs::kProfileLastUsed,
                          dest_path2.BaseName().MaybeAsASCII());
   profile_manager->ScheduleProfileForDeletion(dest_path2,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
 }
 #endif  // !defined(OS_MACOSX)