Refactor ProfileInfoCache in c/b/profiles

chrome/browser/profiles/profile_manager_browsertest.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
-#include "chrome/browser/profiles/profile_info_cache.h"
-#include "chrome/browser/profiles/profile_info_cache_observer.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_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
@@ skipping 36 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void EphemeralProfileCreationComplete(Profile* profile,
                                       Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED)
     profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
   ProfileCreationComplete(profile, status);
 }
 
-class ProfileRemovalObserver : public ProfileInfoCacheObserver {
+class ProfileRemovalObserver : public ProfileAttributesStorage::Observer {
  public:
   ProfileRemovalObserver() {
-    g_browser_process->profile_manager()->GetProfileInfoCache().AddObserver(
-        this);
+    g_browser_process->profile_manager()->GetProfileAttributesStorage().
+        AddObserver(this);
   }
 
   ~ProfileRemovalObserver() override {
-    g_browser_process->profile_manager()->GetProfileInfoCache().RemoveObserver(
-        this);
+    g_browser_process->profile_manager()->GetProfileAttributesStorage().
+        RemoveObserver(this);
   }
 
   std::string last_used_profile_name() { return last_used_profile_name_; }
 
-  // ProfileInfoCacheObserver overrides:
+  // ProfileAttributesStorage::Observer overrides:
   void OnProfileWillBeRemoved(const base::FilePath& profile_path) override {
     last_used_profile_name_ = g_browser_process->local_state()->GetString(
         prefs::kProfileLastUsed);
   }
 
  private:
   std::string last_used_profile_name_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileRemovalObserver);
 };
@@ skipping 15 matching lines @@
 
   const std::vector<autofill::PasswordForm*>& GetPasswords() const {
     return password_entries_.get();
   }
 
  private:
   base::RunLoop run_loop_;
   ScopedVector<autofill::PasswordForm> password_entries_;
 };
 
-static base::FilePath GetFirstNonSigninProfile(const ProfileInfoCache& cache) {
+static base::FilePath GetFirstNonSigninProfile(
+    ProfileAttributesStorage& storage) {
+  std::vector<ProfileAttributesEntry*> entries =
+      storage.GetAllProfilesAttributesSortedByName();
 #if defined(OS_CHROMEOS)
   const base::FilePath signin_path =
       chromeos::ProfileHelper::GetSigninProfileDir();
-  size_t i, profile_num = cache.GetNumberOfProfiles();
-  for (i = 0; i != profile_num; ++i) {
-    base::FilePath profile_path = cache.GetPathOfProfileAtIndex(i);
+  for (ProfileAttributesEntry* entry : entries) {
+    base::FilePath profile_path = entry->GetPath();
     if (profile_path != signin_path)
       return profile_path;
   }
   return base::FilePath();
 #else
-  return cache.GetPathOfProfileAtIndex(0);
+  return entries.front()->GetPath();
 #endif
 }
 
 }  // namespace
 
 // This file contains tests for the ProfileManager that require a heavyweight
 // InProcessBrowserTest.  These include tests involving profile deletion.
 
 // TODO(jeremy): crbug.com/103355 - These tests should be enabled on all
 // platforms.
 class ProfileManagerBrowserTest : public InProcessBrowserTest {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
 #if defined(OS_CHROMEOS)
     command_line->AppendSwitch(
         chromeos::switches::kIgnoreUserProfileMappingForTests);
 #endif
   }
 };
 
 #if defined(OS_MACOSX)
 
 // Delete single profile and make sure a new one is created.
 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DeleteSingletonProfile) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
   ProfileRemovalObserver observer;
 
   // We should start out with 1 profile.
-  ASSERT_EQ(cache.GetNumberOfProfiles(), 1U);
+  ASSERT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Delete singleton profile.
-  base::FilePath singleton_profile_path = cache.GetPathOfProfileAtIndex(0);
+  base::FilePath singleton_profile_path =
+      storage.GetAllProfilesAttributes().front().GetPath();
   EXPECT_FALSE(singleton_profile_path.empty());
   base::RunLoop run_loop;
   profile_manager->ScheduleProfileForDeletion(
       singleton_profile_path,
       base::Bind(&OnUnblockOnProfileCreation, &run_loop));
 
   // Run the message loop until the profile is actually deleted (as indicated
   // by the callback above being called).
   run_loop.Run();
 
   // Make sure a new profile was created automatically.
-  EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
-  base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
+  base::FilePath new_profile_path =
+      storage.GetAllProfilesAttributes().front().GetPath();
   EXPECT_NE(new_profile_path.value(), singleton_profile_path.value());
 
   // Make sure that last used profile preference is set correctly.
   Profile* last_used = ProfileManager::GetLastUsedProfile();
   EXPECT_EQ(new_profile_path.value(), last_used->GetPath().value());
 
   // Make sure the last used profile was set correctly before the notification
   // was sent.
   std::string last_used_profile_name =
       last_used->GetPath().BaseName().MaybeAsASCII();
   EXPECT_EQ(last_used_profile_name, observer.last_used_profile_name());
 }
 
 // Delete all profiles in a multi profile setup and make sure a new one is
 // created.
 // Crashes/CHECKs. See crbug.com/104851
 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DISABLED_DeleteAllProfiles) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
 
   // Create an additional profile.
   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
   base::RunLoop run_loop;
   profile_manager->CreateProfileAsync(
       new_path, base::Bind(&OnUnblockOnProfileCreation, &run_loop),
       base::string16(), std::string(), std::string());
 
   // Run the message loop to allow profile creation to take place; the loop is
   // terminated by OnUnblockOnProfileCreation when the profile is created.
   run_loop.Run();
 
-  ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
+  ASSERT_EQ(2u, storage.GetNumberOfProfiles());
 
   // Delete all profiles.
-  base::FilePath profile_path1 = cache.GetPathOfProfileAtIndex(0);
-  base::FilePath profile_path2 = cache.GetPathOfProfileAtIndex(1);
-  EXPECT_FALSE(profile_path1.empty());
-  EXPECT_FALSE(profile_path2.empty());
-  profile_manager->ScheduleProfileForDeletion(profile_path1,
-                                              ProfileManager::CreateCallback());
-  profile_manager->ScheduleProfileForDeletion(profile_path2,
-                                              ProfileManager::CreateCallback());
+  std::vector<ProfileAttributesEntry*> entries =
+      storage.GetAllProfilesAttributes();
+  std::vector<base::FilePath> old_profile_paths;
+  for (ProfileAttributesEntry* entry : entries) {
+    profile_path = entry->GetPath();
+    EXPECT_FALSE(profile_path.empty());
+    profile_manager->ScheduleProfileForDeletion(
+        profile_path, ProfileManager::CreateCallback());
+    old_profile_paths.push_back(profile_path);
+  }
 
   // Spin things so deletion can take place.
   content::RunAllPendingInMessageLoop();
 
   // Make sure a new profile was created automatically.
-  EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
-  base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
-  EXPECT_NE(new_profile_path, profile_path1);
-  EXPECT_NE(new_profile_path, profile_path2);
+  EXPECT_EQ(1u, storage.GetNumberOfProfiles());
+  base::FilePath new_profile_path =
+      storage.GetAllProfilesAttributes().front()->GetPath();
+  for (const base::FilePath& old_profile_path : old_profile_paths)
+    EXPECT_NE(old_profile_path, new_profile_path);
 
   // Make sure that last used profile preference is set correctly.
   Profile* last_used = ProfileManager::GetLastUsedProfile();
   EXPECT_EQ(new_profile_path, last_used->GetPath());
 }
 #endif  // OS_MACOSX
 
 #if defined(OS_CHROMEOS)
 
 class ProfileManagerCrOSBrowserTest : public ProfileManagerBrowserTest {
@@ skipping 56 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshBrowserTests))
     return;
 #endif
 
   // If multiprofile mode is not enabled, you can't switch between profiles.
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
   size_t initial_profile_count = profile_manager->GetNumberOfProfiles();
-  base::FilePath path_profile1 = GetFirstNonSigninProfile(cache);
+  base::FilePath path_profile1 = GetFirstNonSigninProfile(storage);
 
   ASSERT_NE(0U, initial_profile_count);
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
 
   // Create an additional profile.
   base::FilePath path_profile2 =
       profile_manager->GenerateNextProfileDirectoryPath();
   base::RunLoop run_loop;
   profile_manager->CreateProfileAsync(
       path_profile2, base::Bind(&OnUnblockOnProfileCreation, &run_loop),
       base::string16(), std::string(), std::string());
 
   // Run the message loop to allow profile creation to take place; the loop is
   // terminated by OnUnblockOnProfileCreation when the profile is created.
   run_loop.Run();
 
   BrowserList* browser_list = BrowserList::GetInstance();
-  ASSERT_EQ(initial_profile_count + 1, cache.GetNumberOfProfiles());
+  ASSERT_EQ(initial_profile_count + 1U, storage.GetNumberOfProfiles());
   EXPECT_EQ(1U, browser_list->size());
 
   // Open a browser window for the first profile.
   profiles::SwitchToProfile(path_profile1, false, kOnProfileSwitchDoNothing,
                             ProfileMetrics::SWITCH_PROFILE_ICON);
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1U, browser_list->size());
   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
 
   // Open a browser window for the second profile.
@@ skipping 25 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshBrowserTests))
     return;
 #endif
 
   // If multiprofile mode is not enabled, you can't switch between profiles.
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
+  ProfileAttributesStorage& storage =
+      profile_manager->GetProfileAttributesStorage();
   size_t initial_profile_count = profile_manager->GetNumberOfProfiles();
-  base::FilePath path_profile1 = GetFirstNonSigninProfile(cache);
+  base::FilePath path_profile1 = GetFirstNonSigninProfile(storage);
 
   ASSERT_NE(0U, initial_profile_count);
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
 
   // Create an ephemeral profile.
   base::FilePath path_profile2 =
       profile_manager->GenerateNextProfileDirectoryPath();
   profile_manager->CreateProfileAsync(
       path_profile2,
       base::Bind(&EphemeralProfileCreationComplete),
       base::string16(), std::string(), std::string());
 
   // Spin to allow profile creation to take place.
   content::RunMessageLoop();
 
   BrowserList* browser_list = BrowserList::GetInstance();
-  ASSERT_EQ(initial_profile_count + 1, cache.GetNumberOfProfiles());
+  ASSERT_EQ(initial_profile_count + 1U, storage.GetNumberOfProfiles());
   EXPECT_EQ(1U, browser_list->size());
 
   // Open a browser window for the second profile.
   profiles::SwitchToProfile(path_profile2, false, kOnProfileSwitchDoNothing,
                             ProfileMetrics::SWITCH_PROFILE_ICON);
   EXPECT_EQ(2U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2U, browser_list->size());
   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
 
   // Create a second window for the ephemeral profile.
   profiles::SwitchToProfile(path_profile2, true, kOnProfileSwitchDoNothing,
                             ProfileMetrics::SWITCH_PROFILE_ICON);
   EXPECT_EQ(3U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(3U, browser_list->size());
 
   EXPECT_EQ(path_profile1, browser_list->get(0)->profile()->GetPath());
   EXPECT_EQ(path_profile2, browser_list->get(1)->profile()->GetPath());
   EXPECT_EQ(path_profile2, browser_list->get(2)->profile()->GetPath());
 
   // Closing the first window of the ephemeral profile should not delete it.
   CloseBrowserSynchronously(browser_list->get(2));
   EXPECT_EQ(2U, browser_list->size());
-  EXPECT_EQ(initial_profile_count + 1, cache.GetNumberOfProfiles());
+  EXPECT_EQ(initial_profile_count + 1U, storage.GetNumberOfProfiles());
 
   // The second should though.
   CloseBrowserSynchronously(browser_list->get(1));
   EXPECT_EQ(1U, browser_list->size());
-  EXPECT_EQ(initial_profile_count, cache.GetNumberOfProfiles());
+  EXPECT_EQ(initial_profile_count, storage.GetNumberOfProfiles());
 }
 
 // The test makes sense on those platforms where the keychain exists.
 #if !defined(OS_WIN) && !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DeletePasswords) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
   ASSERT_TRUE(profile);
 
   autofill::PasswordForm form;
   form.scheme = autofill::PasswordForm::SCHEME_HTML;
@@ skipping 66 matching lines @@
 
   EXPECT_FALSE(profile->HasOffTheRecordProfile());
   EXPECT_FALSE(profile_manager->IsValidProfile(incognito_profile));
   EXPECT_EQ(initial_profile_count, profile_manager->GetNumberOfProfiles());
   // After destroying the incognito profile incognito preferences should be
   // cleared so the default save path should be taken from the main profile.
   EXPECT_FALSE(profile->GetOffTheRecordPrefs()
                    ->GetFilePath(prefs::kSaveFileDefaultDirectory)
                    .empty());
 }