Refactor most c/b/profiles calls to ProfileInfoCache.

chrome/browser/profiles/profile_shortcut_manager_unittest_win.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 <objbase.h>  // For CoInitialize().
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/test_shortcut_win.h"
 #include "base/win/shortcut.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_attributes_entry.h"
+#include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_shortcut_manager.h"
 #include "chrome/browser/profiles/profile_shortcut_manager_win.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 class ProfileShortcutManagerTest : public testing::Test {
  protected:
   ProfileShortcutManagerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
-        profile_info_cache_(NULL),
+        profile_attributes_storage_(NULL),
         fake_user_desktop_(base::DIR_USER_DESKTOP),
         fake_system_desktop_(base::DIR_COMMON_DESKTOP) {
   }
 
   void SetUp() override {
     CoInitialize(NULL);
 
     TestingBrowserProcess* browser_process =
         TestingBrowserProcess::GetGlobal();
     profile_manager_.reset(new TestingProfileManager(browser_process));
     ASSERT_TRUE(profile_manager_->SetUp());
-    profile_info_cache_ = profile_manager_->profile_info_cache();
+    profile_attributes_storage_ =
+        profile_manager_->profile_attributes_storage();
     profile_shortcut_manager_.reset(
         ProfileShortcutManager::Create(profile_manager_->profile_manager()));
     profile_1_name_ = L"My profile";
     profile_1_path_ = CreateProfileDirectory(profile_1_name_);
     profile_2_name_ = L"My profile 2";
     profile_2_path_ = CreateProfileDirectory(profile_2_name_);
     profile_3_name_ = L"My profile 3";
     profile_3_path_ = CreateProfileDirectory(profile_3_name_);
   }
 
   void TearDown() override {
     message_loop_.RunUntilIdle();
 
     // Delete all profiles and ensure their shortcuts got removed.
-    const int num_profiles = profile_info_cache_->GetNumberOfProfiles();
+    const int num_profiles = profile_attributes_storage_->GetNumberOfProfiles();
     for (int i = 0; i < num_profiles; ++i) {
-      const base::FilePath profile_path =
-          profile_info_cache_->GetPathOfProfileAtIndex(0);
-      base::string16 profile_name =
-          profile_info_cache_->GetNameOfProfileAtIndex(0);
-      profile_info_cache_->DeleteProfileFromCache(profile_path);
+      std::vector<ProfileAttributesEntry*> entries =
+          profile_attributes_storage_->GetAllProfilesAttributes();
+      const base::FilePath profile_path = entries[0]->GetPath();
+      base::string16 profile_name = entries[0]->GetName();
+      profile_attributes_storage_->RemoveProfile(profile_path);
       RunPendingTasks();
       ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name));
       // The icon file is not deleted until the profile directory is deleted.
       const base::FilePath icon_path =
           profiles::internal::GetProfileIconPath(profile_path);
       ASSERT_TRUE(base::PathExists(icon_path));
     }
   }
 
   base::FilePath CreateProfileDirectory(const base::string16& profile_name) {
     const base::FilePath profile_path =
-        profile_info_cache_->GetUserDataDir().Append(profile_name);
+        profile_attributes_storage_->GetUserDataDir().Append(profile_name);
     base::CreateDirectory(profile_path);
     return profile_path;
   }
 
   void RunPendingTasks() {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
   }
 
   void SetupDefaultProfileShortcut(const tracked_objects::Location& location) {
-    ASSERT_EQ(0, profile_info_cache_->GetNumberOfProfiles())
+    ASSERT_EQ(0, profile_attributes_storage_->GetNumberOfProfiles())
         << location.ToString();
     ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_))
         << location.ToString();
-    profile_info_cache_->AddProfileToCache(profile_1_path_, profile_1_name_,
-                                           std::string(), base::string16(), 0,
-                                           std::string());
+    profile_attributes_storage_->AddProfile(profile_1_path_, profile_1_name_,
+                                            std::string(), base::string16(), 0,
+                                            std::string());
     // Also create a non-badged shortcut for Chrome, which is conveniently done
     // by |CreateProfileShortcut()| since there is only one profile.
     profile_shortcut_manager_->CreateProfileShortcut(profile_1_path_);
     RunPendingTasks();
     // Verify that there's now a shortcut with no profile information.
     ValidateNonProfileShortcut(location);
   }
 
   void SetupAndCreateTwoShortcuts(const tracked_objects::Location& location) {
     SetupDefaultProfileShortcut(location);
@@ skipping 66 matching lines @@
     const base::FilePath shortcut_path =
         GetDefaultShortcutPathForProfile(base::string16());
     ValidateNonProfileShortcutAtPath(location, shortcut_path);
   }
 
   void CreateProfileWithShortcut(const tracked_objects::Location& location,
                                  const base::string16& profile_name,
                                  const base::FilePath& profile_path) {
     ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name))
         << location.ToString();
-    profile_info_cache_->AddProfileToCache(profile_path, profile_name,
-                                           std::string(), base::string16(), 0,
-                                           std::string());
+    profile_attributes_storage_->AddProfile(profile_path, profile_name,
+                                            std::string(), base::string16(), 0,
+                                            std::string());
     profile_shortcut_manager_->CreateProfileShortcut(profile_path);
     RunPendingTasks();
     ValidateProfileShortcut(location, profile_name, profile_path);
   }
 
   // Creates a regular (non-profile) desktop shortcut with the given name and
   // returns its path. Fails the test if an error occurs.
   base::FilePath CreateRegularShortcutWithName(
       const tracked_objects::Location& location,
       const base::string16& shortcut_name) {
@@ skipping 28 matching lines @@
                 GetShortcutName(BrowserDistribution::SHORTCUT_CHROME) +
                 installer::kLnkExt);
     EXPECT_TRUE(base::PathExists(system_level_shortcut_path))
         << location.ToString();
     return system_level_shortcut_path;
   }
 
   void RenameProfile(const tracked_objects::Location& location,
                      const base::FilePath& profile_path,
                      const base::string16& new_profile_name) {
-    const size_t profile_index =
-        profile_info_cache_->GetIndexOfProfileWithPath(profile_2_path_);
-    ASSERT_NE(std::string::npos, profile_index);
-    ASSERT_NE(profile_info_cache_->GetNameOfProfileAtIndex(profile_index),
-              new_profile_name);
-    profile_info_cache_->SetNameOfProfileAtIndex(profile_index,
-                                                 new_profile_name);
+    ProfileAttributesEntry* entry;
+    ASSERT_TRUE(profile_attributes_storage_->GetProfileAttributesWithPath(
+        profile_2_path_, &entry));
+    ASSERT_NE(entry->GetName(), new_profile_name);
+    entry->SetName(new_profile_name);
     RunPendingTasks();
   }
 
   BrowserDistribution* GetDistribution() {
     return BrowserDistribution::GetDistribution();
   }
 
   base::FilePath GetExePath() {
     base::FilePath exe_path;
     EXPECT_TRUE(PathService::Get(base::FILE_EXE, &exe_path));
@@ skipping 16 matching lines @@
                                            ShellUtil::SYSTEM_LEVEL,
                                            &system_shortcuts_directory));
     return system_shortcuts_directory;
   }
 
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   scoped_ptr<ProfileShortcutManager> profile_shortcut_manager_;
-  ProfileInfoCache* profile_info_cache_;
+  ProfileAttributesStorage* profile_attributes_storage_;
   base::ScopedPathOverride fake_user_desktop_;
   base::ScopedPathOverride fake_system_desktop_;
   base::string16 profile_1_name_;
   base::FilePath profile_1_path_;
   base::string16 profile_2_name_;
   base::FilePath profile_2_path_;
   base::string16 profile_3_name_;
   base::FilePath profile_3_path_;
 };
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(
       distribution->GetShortcutName(BrowserDistribution::SHORTCUT_CHROME) +
           installer::kLnkExt,
       profiles::internal::GetShortcutFilenameForProfile(base::string16(),
                                                         distribution));
 }
 
 TEST_F(ProfileShortcutManagerTest, ShortcutFlags) {
   const base::string16 kProfileName = L"MyProfileX";
   const base::FilePath profile_path =
-      profile_info_cache_->GetUserDataDir().Append(kProfileName);
+      profile_attributes_storage_->GetUserDataDir().Append(kProfileName);
   EXPECT_EQ(L"--profile-directory=\"" + kProfileName + L"\"",
             profiles::internal::CreateProfileShortcutFlags(profile_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsCreate) {
   SetupDefaultProfileShortcut(FROM_HERE);
   // Validation is done by |ValidateProfileShortcutAtPath()| which is called
   // by |CreateProfileWithShortcut()|.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsUpdate) {
   SetupDefaultProfileShortcut(FROM_HERE);
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
 
   // Cause an update in ProfileShortcutManager by modifying the profile info
   // cache.
   const base::string16 new_profile_2_name = L"New Profile Name";
   RenameProfile(FROM_HERE, profile_2_path_, new_profile_2_name);
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   ValidateProfileShortcut(FROM_HERE, new_profile_2_name, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, CreateSecondProfileBadgesFirstShortcut) {
   SetupDefaultProfileShortcut(FROM_HERE);
   // Assert that a shortcut without a profile name exists.
   ASSERT_TRUE(ProfileShortcutExistsAtDefaultPath(base::string16()));
 
   // Create a second profile without a shortcut.
-  profile_info_cache_->AddProfileToCache(profile_2_path_, profile_2_name_,
-                                         std::string(), base::string16(), 0,
-                                         std::string());
+  profile_attributes_storage_->AddProfile(profile_2_path_, profile_2_name_,
+                                          std::string(), base::string16(), 0,
+                                          std::string());
   RunPendingTasks();
 
   // Ensure that the second profile doesn't have a shortcut and that the first
   // profile's shortcut got renamed and badged.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(base::string16()));
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsDeleteSecondToLast) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   // Delete one shortcut.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
 
   // Verify that the profile name has been removed from the remaining shortcut.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that an additional shortcut, with the default profile's name does
   // not exist.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteSecondToLastProfileWithoutShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   // Delete the profile that doesn't have a shortcut.
-  profile_info_cache_->DeleteProfileFromCache(profile_1_path_);
+  profile_attributes_storage_->RemoveProfile(profile_1_path_);
   RunPendingTasks();
 
   // Verify that the remaining shortcut does not have a profile name.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that shortcuts with profile names do not exist.
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteSecondToLastProfileWithShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   // Delete the profile that has a shortcut.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
 
   // Verify that the remaining shortcut does not have a profile name.
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that shortcuts with profile names do not exist.
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DeleteOnlyProfileWithShortcuts) {
@@ skipping 14 matching lines @@
   ASSERT_TRUE(base::DeleteFile(profile_2_shortcut_path, false));
 
   // Only the shortcut to the third profile should exist.
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_2_shortcut_path));
   ASSERT_FALSE(base::PathExists(non_profile_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_3_shortcut_path));
 
   // Delete the third profile and check that its shortcut is gone and no
   // shortcuts have been re-created.
-  profile_info_cache_->DeleteProfileFromCache(profile_3_path_);
+  profile_attributes_storage_->RemoveProfile(profile_3_path_);
   RunPendingTasks();
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_2_shortcut_path));
   ASSERT_FALSE(base::PathExists(profile_3_shortcut_path));
   ASSERT_FALSE(base::PathExists(non_profile_shortcut_path));
 }
 
 TEST_F(ProfileShortcutManagerTest, DesktopShortcutsCreateSecond) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   // Delete one shortcut.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
 
   // Verify that a default shortcut exists (no profile name/avatar).
   ValidateNonProfileShortcut(FROM_HERE);
   // Verify that an additional shortcut, with the first profile's name does
   // not exist.
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
 
   // Create a second profile and shortcut.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
@@ skipping 46 matching lines @@
 
   // Also, copy the shortcut for the first user and ensure it gets preserved.
   const base::FilePath preserved_profile_1_shortcut_path =
       GetUserShortcutsDirectory().Append(L"Preserved.lnk");
   ASSERT_TRUE(base::CopyFile(
       GetDefaultShortcutPathForProfile(profile_1_name_),
       preserved_profile_1_shortcut_path));
   EXPECT_TRUE(base::PathExists(preserved_profile_1_shortcut_path));
 
   // Delete the profile and ensure both shortcuts were also deleted.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_1));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path_2));
   ValidateNonProfileShortcutAtPath(FROM_HERE,
                                    preserved_profile_1_shortcut_path);
 }
 
 TEST_F(ProfileShortcutManagerTest, RenamedDesktopShortcutsAfterProfileRename) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
@@ skipping 123 matching lines @@
   profile_shortcut_manager_->HasProfileShortcuts(profile_2_path_, callback);
   RunPendingTasks();
   EXPECT_FALSE(result.has_shortcuts);
 }
 
 TEST_F(ProfileShortcutManagerTest, ProfileShortcutsWithSystemLevelShortcut) {
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Create the initial profile.
-  profile_info_cache_->AddProfileToCache(profile_1_path_, profile_1_name_,
-                                         std::string(), base::string16(), 0,
-                                         std::string());
+  profile_attributes_storage_->AddProfile(profile_1_path_, profile_1_name_,
+                                          std::string(), base::string16(), 0,
+                                          std::string());
   RunPendingTasks();
-  ASSERT_EQ(1U, profile_info_cache_->GetNumberOfProfiles());
+  ASSERT_EQ(1U, profile_attributes_storage_->GetNumberOfProfiles());
 
   // Ensure system-level continues to exist and user-level was not created.
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(base::string16())));
 
   // Create another profile with a shortcut and ensure both profiles receive
   // user-level profile shortcuts and the system-level one still exists.
   CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   ValidateProfileShortcut(FROM_HERE, profile_1_name_, profile_1_path_);
   ValidateProfileShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
 
   // Create a third profile without a shortcut and ensure it doesn't get one.
-  profile_info_cache_->AddProfileToCache(profile_3_path_, profile_3_name_,
-                                         std::string(), base::string16(), 0,
-                                         std::string());
+  profile_attributes_storage_->AddProfile(profile_3_path_, profile_3_name_,
+                                          std::string(), base::string16(), 0,
+                                          std::string());
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
 
+  ProfileAttributesEntry* profile_3_entry;
+  ASSERT_TRUE(profile_attributes_storage_->GetProfileAttributesWithPath(
+      profile_3_path_, &profile_3_entry));
   // Ensure that changing the avatar icon and the name does not result in a
   // shortcut being created.
-  profile_info_cache_->SetAvatarIconOfProfileAtIndex(
-      profile_info_cache_->GetIndexOfProfileWithPath(profile_3_path_), 3);
+  profile_3_entry->SetAvatarIconIndex(3);
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
 
   const base::string16 new_profile_3_name = L"New Name 3";
-  profile_info_cache_->SetNameOfProfileAtIndex(
-      profile_info_cache_->GetIndexOfProfileWithPath(profile_3_path_),
-      new_profile_3_name);
+  profile_3_entry->SetName(new_profile_3_name);
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_3_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(new_profile_3_name));
 
+  ProfileAttributesEntry* profile_2_entry;
+  ASSERT_TRUE(profile_attributes_storage_->GetProfileAttributesWithPath(
+      profile_2_path_, &profile_2_entry));
   // Rename the second profile and ensure its shortcut got renamed.
   const base::string16 new_profile_2_name = L"New Name 2";
-  profile_info_cache_->SetNameOfProfileAtIndex(
-      profile_info_cache_->GetIndexOfProfileWithPath(profile_2_path_),
-      new_profile_2_name);
+  profile_2_entry->SetName(new_profile_2_name);
   RunPendingTasks();
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
   ValidateProfileShortcut(FROM_HERE, new_profile_2_name, profile_2_path_);
 }
 
 TEST_F(ProfileShortcutManagerTest,
        DeleteSecondToLastProfileWithSystemLevelShortcut) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Delete a profile and verify that only the system-level shortcut still
   // exists.
-  profile_info_cache_->DeleteProfileFromCache(profile_1_path_);
+  profile_attributes_storage_->RemoveProfile(profile_1_path_);
   RunPendingTasks();
 
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(base::string16()));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_1_name_));
   EXPECT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_2_name_));
 }
 
 TEST_F(ProfileShortcutManagerTest,
        DeleteSecondToLastProfileWithShortcutWhenSystemLevelShortcutExists) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
 
   const base::FilePath profile_1_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_1_name_);
   const base::FilePath profile_2_shortcut_path =
       GetDefaultShortcutPathForProfile(profile_2_name_);
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::DeleteFile(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Delete the profile that has a shortcut, which will exercise the non-profile
   // shortcut creation path in |DeleteDesktopShortcuts()|, which is
   // not covered by the |DeleteSecondToLastProfileWithSystemLevelShortcut| test.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
 
   // Verify that only the system-level shortcut still exists.
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(base::string16())));
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
 
@@ skipping 31 matching lines @@
   std::string badged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &badged_icon_1));
   std::string badged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &badged_icon_2));
 
   EXPECT_NE(badged_icon_1, unbadged_icon_1);
   EXPECT_EQ(badged_icon_1, badged_icon_2);
 
   // Deleting the default profile will unbadge the new profile's icon and should
   // result in an icon that is identical to the unbadged default profile icon.
-  profile_info_cache_->DeleteProfileFromCache(profile_1_path_);
+  profile_attributes_storage_->RemoveProfile(profile_1_path_);
   RunPendingTasks();
 
   std::string unbadged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &unbadged_icon_2));
   EXPECT_EQ(unbadged_icon_1, unbadged_icon_2);
 }
 
 TEST_F(ProfileShortcutManagerTest, ProfileIconOnAvatarChange) {
   SetupAndCreateTwoShortcuts(FROM_HERE);
   const base::FilePath icon_path_1 =
       profiles::internal::GetProfileIconPath(profile_1_path_);
   const base::FilePath icon_path_2 =
       profiles::internal::GetProfileIconPath(profile_2_path_);
-  const size_t profile_index_1 =
-      profile_info_cache_->GetIndexOfProfileWithPath(profile_1_path_);
 
   std::string badged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &badged_icon_1));
   std::string badged_icon_2;
   EXPECT_TRUE(base::ReadFileToString(icon_path_2, &badged_icon_2));
 
   // Profile 1 and 2 are created with the same icon.
   EXPECT_EQ(badged_icon_1, badged_icon_2);
 
+  ProfileAttributesEntry* entry;
+  ASSERT_TRUE(profile_attributes_storage_->GetProfileAttributesWithPath(
+      profile_1_path_, &entry));
   // Change profile 1's icon.
-  profile_info_cache_->SetAvatarIconOfProfileAtIndex(profile_index_1, 1);
+  entry->SetAvatarIconIndex(1);
   RunPendingTasks();
 
   std::string new_badged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &new_badged_icon_1));
   EXPECT_NE(new_badged_icon_1, badged_icon_1);
 
   // Ensure the new icon is not the unbadged icon.
-  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  profile_attributes_storage_->RemoveProfile(profile_2_path_);
   RunPendingTasks();
 
   std::string unbadged_icon_1;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &unbadged_icon_1));
   EXPECT_NE(unbadged_icon_1, new_badged_icon_1);
 
   // Ensure the icon doesn't change on avatar change without 2 profiles.
-  profile_info_cache_->SetAvatarIconOfProfileAtIndex(profile_index_1, 1);
+  entry->SetAvatarIconIndex(1);
   RunPendingTasks();
 
   std::string unbadged_icon_1_a;
   EXPECT_TRUE(base::ReadFileToString(icon_path_1, &unbadged_icon_1_a));
   EXPECT_EQ(unbadged_icon_1, unbadged_icon_1_a);
 }