text: // 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_info_cache_unittest.h"
  
  #include <vector>
  
  #include "base/command_line.h"
  #include "base/files/file_util.h"
  #include "base/prefs/testing_pref_service.h"
  #include "base/strings/stringprintf.h"
  #include "base/strings/utf_string_conversions.h"
  #include "base/time/time.h"
  #include "chrome/browser/browser_process.h"
  #include "chrome/browser/chrome_notification_types.h"
  #include "chrome/browser/prefs/pref_service_syncable.h"
  #include "chrome/browser/profiles/profile_avatar_downloader.h"
  #include "chrome/browser/profiles/profile_avatar_icon_util.h"
  #include "chrome/browser/profiles/profile_info_cache.h"
  #include "chrome/browser/profiles/profile_manager.h"
  #include "chrome/common/chrome_switches.h"
  #include "chrome/test/base/testing_browser_process.h"
  #include "components/signin/core/common/profile_management_switches.h"
  #include "content/public/browser/notification_observer.h"
  #include "content/public/browser/notification_registrar.h"
  #include "content/public/browser/notification_service.h"
  #include "content/public/test/test_browser_thread_bundle.h"
  #include "content/public/test/test_utils.h"
  #include "third_party/skia/include/core/SkBitmap.h"
  #include "ui/base/resource/resource_bundle.h"
  #include "ui/gfx/image/image.h"
  #include "ui/gfx/image/image_unittest_util.h"
  
  using base::ASCIIToUTF16;
  using base::UTF8ToUTF16;
  using content::BrowserThread;
  
  ProfileNameVerifierObserver::ProfileNameVerifierObserver(
      TestingProfileManager* testing_profile_manager)
      : testing_profile_manager_(testing_profile_manager) {
    DCHECK(testing_profile_manager_);
  }
  
  ProfileNameVerifierObserver::~ProfileNameVerifierObserver() {
  }
  
  void ProfileNameVerifierObserver::OnProfileAdded(
      const base::FilePath& profile_path) {
    base::string16 profile_name = GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(profile_path));
    EXPECT_TRUE(profile_names_.find(profile_name) == profile_names_.end());
    profile_names_.insert(profile_name);
  }
  
  void ProfileNameVerifierObserver::OnProfileWillBeRemoved(
      const base::FilePath& profile_path) {
    base::string16 profile_name = GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(profile_path));
    EXPECT_TRUE(profile_names_.find(profile_name) != profile_names_.end());
    profile_names_.erase(profile_name);
  }
  
  void ProfileNameVerifierObserver::OnProfileWasRemoved(
      const base::FilePath& profile_path,
      const base::string16& profile_name) {
    EXPECT_TRUE(profile_names_.find(profile_name) == profile_names_.end());
  }
  
  void ProfileNameVerifierObserver::OnProfileNameChanged(
      const base::FilePath& profile_path,
      const base::string16& old_profile_name) {
    base::string16 new_profile_name = GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(profile_path));
    EXPECT_TRUE(profile_names_.find(old_profile_name) != profile_names_.end());
    EXPECT_TRUE(profile_names_.find(new_profile_name) == profile_names_.end());
    profile_names_.erase(old_profile_name);
    profile_names_.insert(new_profile_name);
  }
  
  void ProfileNameVerifierObserver::OnProfileAvatarChanged(
      const base::FilePath& profile_path) {
    base::string16 profile_name = GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(profile_path));
    EXPECT_TRUE(profile_names_.find(profile_name) != profile_names_.end());
  }
  
  ProfileInfoCache* ProfileNameVerifierObserver::GetCache() {
    return testing_profile_manager_->profile_info_cache();
  }
  
  ProfileInfoCacheTest::ProfileInfoCacheTest()
      : testing_profile_manager_(TestingBrowserProcess::GetGlobal()),
        name_observer_(&testing_profile_manager_) {
  }
  
  ProfileInfoCacheTest::~ProfileInfoCacheTest() {
  }
  
  void ProfileInfoCacheTest::SetUp() {
    ASSERT_TRUE(testing_profile_manager_.SetUp());
    testing_profile_manager_.profile_info_cache()->AddObserver(&name_observer_);
  }
  
  void ProfileInfoCacheTest::TearDown() {
    // Drain the UI thread to make sure all tasks are completed. This prevents
    // memory leaks.
    base::RunLoop().RunUntilIdle();
  }
  
  ProfileInfoCache* ProfileInfoCacheTest::GetCache() {
    return testing_profile_manager_.profile_info_cache();
  }
  
  base::FilePath ProfileInfoCacheTest::GetProfilePath(
      const std::string& base_name) {
    return testing_profile_manager_.profile_manager()->user_data_dir().
        AppendASCII(base_name);
  }
  
  void ProfileInfoCacheTest::ResetCache() {
    testing_profile_manager_.DeleteProfileInfoCache();
  }
  
  TEST_F(ProfileInfoCacheTest, AddProfiles) {
    EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
  
    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
    for (uint32 i = 0; i < 4; ++i) {
      base::FilePath profile_path =
          GetProfilePath(base::StringPrintf("path_%ud", i));
      base::string16 profile_name =
          ASCIIToUTF16(base::StringPrintf("name_%ud", i));
      const SkBitmap* icon = rb.GetImageNamed(
          profiles::GetDefaultAvatarIconResourceIDAtIndex(
              i)).ToSkBitmap();
      std::string supervised_user_id = i == 3 ? "TEST_ID" : "";
  
      GetCache()->AddProfileToCache(profile_path, profile_name, base::string16(),
                                    i, supervised_user_id);
      GetCache()->SetBackgroundStatusOfProfileAtIndex(i, true);
      base::string16 gaia_name = ASCIIToUTF16(base::StringPrintf("gaia_%ud", i));
      GetCache()->SetGAIANameOfProfileAtIndex(i, gaia_name);
  
      EXPECT_EQ(i + 1, GetCache()->GetNumberOfProfiles());
      EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(i));
      EXPECT_EQ(profile_path, GetCache()->GetPathOfProfileAtIndex(i));
      const SkBitmap* actual_icon =
          GetCache()->GetAvatarIconOfProfileAtIndex(i).ToSkBitmap();
      EXPECT_EQ(icon->width(), actual_icon->width());
      EXPECT_EQ(icon->height(), actual_icon->height());
      EXPECT_EQ(i == 3, GetCache()->ProfileIsSupervisedAtIndex(i));
      EXPECT_EQ(i == 3, GetCache()->IsOmittedProfileAtIndex(i));
      EXPECT_EQ(supervised_user_id,
                GetCache()->GetSupervisedUserIdOfProfileAtIndex(i));
    }
  
    // Reset the cache and test the it reloads correctly.
    ResetCache();
  
    EXPECT_EQ(4u, GetCache()->GetNumberOfProfiles());
    for (uint32 i = 0; i < 4; ++i) {
      base::FilePath profile_path =
            GetProfilePath(base::StringPrintf("path_%ud", i));
      EXPECT_EQ(i, GetCache()->GetIndexOfProfileWithPath(profile_path));
      base::string16 profile_name =
          ASCIIToUTF16(base::StringPrintf("name_%ud", i));
      EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(i));
      EXPECT_EQ(i, GetCache()->GetAvatarIconIndexOfProfileAtIndex(i));
      EXPECT_EQ(true, GetCache()->GetBackgroundStatusOfProfileAtIndex(i));
      base::string16 gaia_name = ASCIIToUTF16(base::StringPrintf("gaia_%ud", i));
      EXPECT_EQ(gaia_name, GetCache()->GetGAIANameOfProfileAtIndex(i));
    }
  }
  
  TEST_F(ProfileInfoCacheTest, DeleteProfile) {
    EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
  
    base::FilePath path_1 = GetProfilePath("path_1");
    GetCache()->AddProfileToCache(path_1, ASCIIToUTF16("name_1"),
                                  base::string16(), 0, std::string());
    EXPECT_EQ(1u, GetCache()->GetNumberOfProfiles());
  
    base::FilePath path_2 = GetProfilePath("path_2");
    base::string16 name_2 = ASCIIToUTF16("name_2");
    GetCache()->AddProfileToCache(path_2, name_2, base::string16(), 0,
                                  std::string());
    EXPECT_EQ(2u, GetCache()->GetNumberOfProfiles());
  
    GetCache()->DeleteProfileFromCache(path_1);
    EXPECT_EQ(1u, GetCache()->GetNumberOfProfiles());
    EXPECT_EQ(name_2, GetCache()->GetNameOfProfileAtIndex(0));
  
    GetCache()->DeleteProfileFromCache(path_2);
    EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
  }
  
  TEST_F(ProfileInfoCacheTest, MutateProfile) {
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("name_1"),
        base::string16(), 0, std::string());
    GetCache()->AddProfileToCache(
        GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
        base::string16(), 0, std::string());
  
    base::string16 new_name = ASCIIToUTF16("new_name");
    GetCache()->SetNameOfProfileAtIndex(1, new_name);
    EXPECT_EQ(new_name, GetCache()->GetNameOfProfileAtIndex(1));
    EXPECT_NE(new_name, GetCache()->GetNameOfProfileAtIndex(0));
  
    base::string16 new_user_name = ASCIIToUTF16("user_name");
    GetCache()->SetUserNameOfProfileAtIndex(1, new_user_name);
    EXPECT_EQ(new_user_name, GetCache()->GetUserNameOfProfileAtIndex(1));
    EXPECT_NE(new_user_name, GetCache()->GetUserNameOfProfileAtIndex(0));
  
    size_t new_icon_index = 3;
    GetCache()->SetAvatarIconOfProfileAtIndex(1, new_icon_index);
    // Not much to test.
    GetCache()->GetAvatarIconOfProfileAtIndex(1);
  }
  
  TEST_F(ProfileInfoCacheTest, Sort) {
    base::string16 name_a = ASCIIToUTF16("apple");
    GetCache()->AddProfileToCache(
        GetProfilePath("path_a"), name_a, base::string16(), 0, std::string());
  
    base::string16 name_c = ASCIIToUTF16("cat");
    GetCache()->AddProfileToCache(
        GetProfilePath("path_c"), name_c, base::string16(), 0, std::string());
  
    // Sanity check the initial order.
    EXPECT_EQ(name_a, GetCache()->GetNameOfProfileAtIndex(0));
    EXPECT_EQ(name_c, GetCache()->GetNameOfProfileAtIndex(1));
  
    // Add a new profile (start with a capital to test case insensitive sorting.
    base::string16 name_b = ASCIIToUTF16("Banana");
    GetCache()->AddProfileToCache(
        GetProfilePath("path_b"), name_b, base::string16(), 0, std::string());
  
    // Verify the new order.
    EXPECT_EQ(name_a, GetCache()->GetNameOfProfileAtIndex(0));
    EXPECT_EQ(name_b, GetCache()->GetNameOfProfileAtIndex(1));
    EXPECT_EQ(name_c, GetCache()->GetNameOfProfileAtIndex(2));
  
    // Change the name of an existing profile.
    name_a = UTF8ToUTF16("dog");
    GetCache()->SetNameOfProfileAtIndex(0, name_a);
  
    // Verify the new order.
    EXPECT_EQ(name_b, GetCache()->GetNameOfProfileAtIndex(0));
    EXPECT_EQ(name_c, GetCache()->GetNameOfProfileAtIndex(1));
    EXPECT_EQ(name_a, GetCache()->GetNameOfProfileAtIndex(2));
  
    // Delete a profile.
    GetCache()->DeleteProfileFromCache(GetProfilePath("path_c"));
  
    // Verify the new order.
    EXPECT_EQ(name_b, GetCache()->GetNameOfProfileAtIndex(0));
    EXPECT_EQ(name_a, GetCache()->GetNameOfProfileAtIndex(1));
  }
  
  TEST_F(ProfileInfoCacheTest, BackgroundModeStatus) {
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("name_1"),
        base::string16(), 0, std::string());
    GetCache()->AddProfileToCache(
        GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
        base::string16(), 0, std::string());
  
    EXPECT_FALSE(GetCache()->GetBackgroundStatusOfProfileAtIndex(0));
    EXPECT_FALSE(GetCache()->GetBackgroundStatusOfProfileAtIndex(1));
  
    GetCache()->SetBackgroundStatusOfProfileAtIndex(1, true);
  
    EXPECT_FALSE(GetCache()->GetBackgroundStatusOfProfileAtIndex(0));
    EXPECT_TRUE(GetCache()->GetBackgroundStatusOfProfileAtIndex(1));
  
    GetCache()->SetBackgroundStatusOfProfileAtIndex(0, true);
  
    EXPECT_TRUE(GetCache()->GetBackgroundStatusOfProfileAtIndex(0));
    EXPECT_TRUE(GetCache()->GetBackgroundStatusOfProfileAtIndex(1));
  
    GetCache()->SetBackgroundStatusOfProfileAtIndex(1, false);
  
    EXPECT_TRUE(GetCache()->GetBackgroundStatusOfProfileAtIndex(0));
    EXPECT_FALSE(GetCache()->GetBackgroundStatusOfProfileAtIndex(1));
  }
  
  TEST_F(ProfileInfoCacheTest, ProfileActiveTime) {
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("name_1"),
        base::string16(), 0, std::string());
    EXPECT_EQ(base::Time(), GetCache()->GetProfileActiveTimeAtIndex(0));
    // Before & After times are artificially shifted because just relying upon
    // the system time can yield problems due to inaccuracies in the
    // underlying storage system (which uses a double with only 52 bits of
    // precision to store the 64-bit "time" number).  http://crbug.com/346827
    base::Time before = base::Time::Now();
    before -= base::TimeDelta::FromSeconds(1);
    GetCache()->SetProfileActiveTimeAtIndex(0);
    base::Time after = base::Time::Now();
    after += base::TimeDelta::FromSeconds(1);
    EXPECT_LE(before, GetCache()->GetProfileActiveTimeAtIndex(0));
    EXPECT_GE(after, GetCache()->GetProfileActiveTimeAtIndex(0));
  }
  
  TEST_F(ProfileInfoCacheTest, GAIAName) {
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("Person 1"),
        base::string16(), 0, std::string());
    base::string16 profile_name(ASCIIToUTF16("Person 2"));
    GetCache()->AddProfileToCache(
        GetProfilePath("path_2"), profile_name, base::string16(), 0,
        std::string());
  
    int index1 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_1"));
    int index2 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_2"));
  
    // Sanity check.
    EXPECT_TRUE(GetCache()->GetGAIANameOfProfileAtIndex(index1).empty());
    EXPECT_TRUE(GetCache()->GetGAIANameOfProfileAtIndex(index2).empty());
  
    // Set GAIA name. This re-sorts the cache.
    base::string16 gaia_name(ASCIIToUTF16("Pat Smith"));
    GetCache()->SetGAIANameOfProfileAtIndex(index2, gaia_name);
    index1 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_1"));
    index2 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_2"));
  
    // Since there is a GAIA name, we use that as a display name.
    EXPECT_TRUE(GetCache()->GetGAIANameOfProfileAtIndex(index1).empty());
    EXPECT_EQ(gaia_name, GetCache()->GetGAIANameOfProfileAtIndex(index2));
    EXPECT_EQ(gaia_name, GetCache()->GetNameOfProfileAtIndex(index2));
  
    // Don't use GAIA name as profile name. This re-sorts the cache.
    base::string16 custom_name(ASCIIToUTF16("Custom name"));
    GetCache()->SetNameOfProfileAtIndex(index2, custom_name);
    GetCache()->SetProfileIsUsingDefaultNameAtIndex(index2, false);
  
    index1 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_1"));
    index2 = GetCache()->GetIndexOfProfileWithPath(GetProfilePath("path_2"));
  
    EXPECT_EQ(custom_name, GetCache()->GetNameOfProfileAtIndex(index2));
    EXPECT_EQ(gaia_name, GetCache()->GetGAIANameOfProfileAtIndex(index2));
  }
  
  TEST_F(ProfileInfoCacheTest, GAIAPicture) {
    const int kDefaultAvatarIndex = 0;
    const int kOtherAvatarIndex = 1;
    const int kGaiaPictureSize = 256;  // Standard size of a Gaia account picture.
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("name_1"),
        base::string16(), kDefaultAvatarIndex, std::string());
    GetCache()->AddProfileToCache(
        GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
        base::string16(), kDefaultAvatarIndex, std::string());
  
    // Sanity check.
    EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(0));
    EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(1));
    EXPECT_FALSE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(0));
    EXPECT_FALSE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(1));
  
    // The profile icon should be the default one.
    EXPECT_TRUE(GetCache()->ProfileIsUsingDefaultAvatarAtIndex(0));
    EXPECT_TRUE(GetCache()->ProfileIsUsingDefaultAvatarAtIndex(1));
    int default_avatar_id =
        profiles::GetDefaultAvatarIconResourceIDAtIndex(kDefaultAvatarIndex);
    const gfx::Image& default_avatar_image(
        ResourceBundle::GetSharedInstance().GetImageNamed(default_avatar_id));
    EXPECT_TRUE(gfx::test::IsEqual(
        default_avatar_image, GetCache()->GetAvatarIconOfProfileAtIndex(1)));
  
    // Set GAIA picture.
    gfx::Image gaia_image(gfx::test::CreateImage(
        kGaiaPictureSize, kGaiaPictureSize));
    GetCache()->SetGAIAPictureOfProfileAtIndex(1, &gaia_image);
    EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(0));
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(1)));
    // Since we're still using the default avatar, the GAIA image should be
    // preferred over the generic avatar image.
    EXPECT_TRUE(GetCache()->ProfileIsUsingDefaultAvatarAtIndex(1));
    EXPECT_TRUE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(1));
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, GetCache()->GetAvatarIconOfProfileAtIndex(1)));
  
    // Set a non-default avatar. This should be preferred over the GAIA image.
    GetCache()->SetAvatarIconOfProfileAtIndex(1, kOtherAvatarIndex);
    GetCache()->SetProfileIsUsingDefaultAvatarAtIndex(1, false);
    EXPECT_FALSE(GetCache()->ProfileIsUsingDefaultAvatarAtIndex(1));
    EXPECT_FALSE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(1));
    int other_avatar_id =
        profiles::GetDefaultAvatarIconResourceIDAtIndex(kOtherAvatarIndex);
    const gfx::Image& other_avatar_image(
        ResourceBundle::GetSharedInstance().GetImageNamed(other_avatar_id));
    EXPECT_TRUE(gfx::test::IsEqual(
        other_avatar_image, GetCache()->GetAvatarIconOfProfileAtIndex(1)));
  
    // Explicitly setting the GAIA picture should make it preferred again.
    GetCache()->SetIsUsingGAIAPictureOfProfileAtIndex(1, true);
    EXPECT_TRUE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(1));
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(1)));
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, GetCache()->GetAvatarIconOfProfileAtIndex(1)));
  
    // Clearing the IsUsingGAIAPicture flag should result in the generic image
    // being used again.
    GetCache()->SetIsUsingGAIAPictureOfProfileAtIndex(1, false);
    EXPECT_FALSE(GetCache()->IsUsingGAIAPictureOfProfileAtIndex(1));
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(1)));
    EXPECT_TRUE(gfx::test::IsEqual(
        other_avatar_image, GetCache()->GetAvatarIconOfProfileAtIndex(1)));
  }
  
  TEST_F(ProfileInfoCacheTest, PersistGAIAPicture) {
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), ASCIIToUTF16("name_1"),
        base::string16(), 0, std::string());
    gfx::Image gaia_image(gfx::test::CreateImage());
  
    content::WindowedNotificationObserver save_observer(
        chrome::NOTIFICATION_PROFILE_CACHE_PICTURE_SAVED,
        content::NotificationService::AllSources());
    GetCache()->SetGAIAPictureOfProfileAtIndex(0, &gaia_image);
    EXPECT_TRUE(gfx::test::IsEqual(
        gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(0)));
  
    // Wait for the file to be written to disk then reset the cache.
    save_observer.Wait();
    ResetCache();
  
    // Try to get the GAIA picture. This should return NULL until the read from
    // disk is done.
    content::WindowedNotificationObserver read_observer(
        chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
        content::NotificationService::AllSources());
    EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(0));
    read_observer.Wait();
    EXPECT_TRUE(gfx::test::IsEqual(
      gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(0)));
  }
  
  TEST_F(ProfileInfoCacheTest, SetSupervisedUserId) {
    GetCache()->AddProfileToCache(
        GetProfilePath("test"), ASCIIToUTF16("Test"),
        base::string16(), 0, std::string());
    EXPECT_FALSE(GetCache()->ProfileIsSupervisedAtIndex(0));
  
    GetCache()->SetSupervisedUserIdOfProfileAtIndex(0, "TEST_ID");
    EXPECT_TRUE(GetCache()->ProfileIsSupervisedAtIndex(0));
    EXPECT_EQ("TEST_ID", GetCache()->GetSupervisedUserIdOfProfileAtIndex(0));
  
    ResetCache();
    EXPECT_TRUE(GetCache()->ProfileIsSupervisedAtIndex(0));
  
    GetCache()->SetSupervisedUserIdOfProfileAtIndex(0, std::string());
    EXPECT_FALSE(GetCache()->ProfileIsSupervisedAtIndex(0));
    EXPECT_EQ("", GetCache()->GetSupervisedUserIdOfProfileAtIndex(0));
  }
  
  TEST_F(ProfileInfoCacheTest, EmptyGAIAInfo) {
    base::string16 profile_name = ASCIIToUTF16("name_1");
    int id = profiles::GetDefaultAvatarIconResourceIDAtIndex(0);
    const gfx::Image& profile_image(
        ResourceBundle::GetSharedInstance().GetImageNamed(id));
  
    GetCache()->AddProfileToCache(
        GetProfilePath("path_1"), profile_name, base::string16(), 0,
                       std::string());
  
    // Set empty GAIA info.
    GetCache()->SetGAIANameOfProfileAtIndex(0, base::string16());
    GetCache()->SetGAIAPictureOfProfileAtIndex(0, NULL);
    GetCache()->SetIsUsingGAIAPictureOfProfileAtIndex(0, true);
  
    // Verify that the profile name and picture are not empty.
    EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(0));
    EXPECT_TRUE(gfx::test::IsEqual(
        profile_image, GetCache()->GetAvatarIconOfProfileAtIndex(0)));
  }
  
  TEST_F(ProfileInfoCacheTest, CreateSupervisedTestingProfile) {
    testing_profile_manager_.CreateTestingProfile("default");
    base::string16 supervised_user_name = ASCIIToUTF16("Supervised User");
    testing_profile_manager_.CreateTestingProfile(
        "test1", scoped_ptr<PrefServiceSyncable>(),
        supervised_user_name, 0, "TEST_ID", TestingProfile::TestingFactories());
    for (size_t i = 0; i < GetCache()->GetNumberOfProfiles(); i++) {
      bool is_supervised =
          GetCache()->GetNameOfProfileAtIndex(i) == supervised_user_name;
      EXPECT_EQ(is_supervised, GetCache()->ProfileIsSupervisedAtIndex(i));
      std::string supervised_user_id = is_supervised ? "TEST_ID" : "";
      EXPECT_EQ(supervised_user_id,
                GetCache()->GetSupervisedUserIdOfProfileAtIndex(i));
    }
  
    // Supervised profiles have a custom theme, which needs to be deleted on the
    // FILE thread. Reset the profile manager now so everything is deleted while
    // we still have a FILE thread.
    TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
  }
  
  TEST_F(ProfileInfoCacheTest, AddStubProfile) {
    EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
  
    // Add some profiles with and without a '.' in their paths.
    const struct {
      const char* profile_path;
      const char* profile_name;
    } kTestCases[] = {
      { "path.test0", "name_0" },
      { "path_test1", "name_1" },
      { "path.test2", "name_2" },
      { "path_test3", "name_3" },
    };
  
    for (size_t i = 0; i < arraysize(kTestCases); ++i) {
      base::FilePath profile_path = GetProfilePath(kTestCases[i].profile_path);
      base::string16 profile_name = ASCIIToUTF16(kTestCases[i].profile_name);
  
      GetCache()->AddProfileToCache(profile_path, profile_name, base::string16(),
                                    i, "");
  
      EXPECT_EQ(profile_path, GetCache()->GetPathOfProfileAtIndex(i));
      EXPECT_EQ(profile_name, GetCache()->GetNameOfProfileAtIndex(i));
    }
  
    ASSERT_EQ(4U, GetCache()->GetNumberOfProfiles());
  
    // Check that the profiles can be extracted from the local state.
    std::vector<base::string16> names = ProfileInfoCache::GetProfileNames();
    for (size_t i = 0; i < 4; i++)
      ASSERT_FALSE(names[i].empty());
  }
  
  // High res avatar downloading is only supported on desktop.
  #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_CHROMEOS)
  TEST_F(ProfileInfoCacheTest, DownloadHighResAvatarTest) {
    switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
  
    EXPECT_EQ(0U, GetCache()->GetNumberOfProfiles());
    base::FilePath path_1 = GetProfilePath("path_1");
    GetCache()->AddProfileToCache(path_1, ASCIIToUTF16("name_1"),
                                  base::string16(), 0, std::string());
    EXPECT_EQ(1U, GetCache()->GetNumberOfProfiles());
  
    // We haven't downloaded any high-res avatars yet.
    EXPECT_EQ(0U, GetCache()->cached_avatar_images_.size());
  
    // After adding a new profile, the download of high-res avatar will be
    // triggered if the flag kNewAvatarMenu has been set. But the downloader
    // won't ever call OnFetchComplete in the test.
    EXPECT_EQ(1U, GetCache()->avatar_images_downloads_in_progress_.size());
  
    EXPECT_FALSE(GetCache()->GetHighResAvatarOfProfileAtIndex(0));
  
    // Simulate downloading a high-res avatar.
    const size_t kIconIndex = 0;
    ProfileAvatarDownloader avatar_downloader(
        kIconIndex, GetCache()->GetPathOfProfileAtIndex(0), GetCache());
  
    // Put a real bitmap into "bitmap".  2x2 bitmap of green 32 bit pixels.
    SkBitmap bitmap;
    bitmap.allocN32Pixels(2, 2);
    bitmap.eraseColor(SK_ColorGREEN);
  
    avatar_downloader.OnFetchComplete(
        GURL("http://www.google.com/avatar.png"), &bitmap);
  
    std::string file_name =
        profiles::GetDefaultAvatarIconFileNameAtIndex(kIconIndex);
  
    // The file should have been cached and saved.
    EXPECT_EQ(1U, GetCache()->avatar_images_downloads_in_progress_.size());
    EXPECT_EQ(1U, GetCache()->cached_avatar_images_.size());
    EXPECT_TRUE(GetCache()->GetHighResAvatarOfProfileAtIndex(0));
    EXPECT_EQ(GetCache()->cached_avatar_images_[file_name],
        GetCache()->GetHighResAvatarOfProfileAtIndex(0));
  
    // Make sure everything has completed, and the file has been written to disk.
    base::RunLoop().RunUntilIdle();
  
    // Clean up.
    base::FilePath icon_path =
        profiles::GetPathOfHighResAvatarAtIndex(kIconIndex);
    EXPECT_NE(std::string::npos, icon_path.MaybeAsASCII().find(file_name));
    EXPECT_TRUE(base::PathExists(icon_path));
    EXPECT_TRUE(base::DeleteFile(icon_path, true));
    EXPECT_FALSE(base::PathExists(icon_path));
  }
  
  TEST_F(ProfileInfoCacheTest, MigrateLegacyProfileNamesWithNewAvatarMenu) {
    switches::EnableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
    EXPECT_EQ(0U, GetCache()->GetNumberOfProfiles());
  
    base::FilePath path_1 = GetProfilePath("path_1");
    GetCache()->AddProfileToCache(path_1, ASCIIToUTF16("Default Profile"),
                                  base::string16(), 0, std::string());
    base::FilePath path_2 = GetProfilePath("path_2");
    GetCache()->AddProfileToCache(path_2, ASCIIToUTF16("First user"),
                                  base::string16(), 1, std::string());
    base::string16 name_3 = ASCIIToUTF16("Lemonade");
    base::FilePath path_3 = GetProfilePath("path_3");
    GetCache()->AddProfileToCache(path_3, name_3,
                                  base::string16(), 2, std::string());
    base::string16 name_4 = ASCIIToUTF16("Batman");
    base::FilePath path_4 = GetProfilePath("path_4");
    GetCache()->AddProfileToCache(path_4, name_4,
                                  base::string16(), 3, std::string());
    base::string16 name_5 = ASCIIToUTF16("Person 2");
    base::FilePath path_5 = GetProfilePath("path_5");
    GetCache()->AddProfileToCache(path_5, name_5,
                                  base::string16(), 2, std::string());
  
    EXPECT_EQ(5U, GetCache()->GetNumberOfProfiles());
  
  
    ResetCache();
  
    // Legacy profile names like "Default Profile" and "First user" should be
    // migrated to "Person %n" type names.
    EXPECT_EQ(ASCIIToUTF16("Person 1"), GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_1)));
    EXPECT_EQ(ASCIIToUTF16("Person 3"), GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_2)));
  
    // Other profile names should not be migrated even if they're the old
    // default cartoon profile names.
    EXPECT_EQ(name_3, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_3)));
    EXPECT_EQ(name_4, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_4)));
    EXPECT_EQ(name_5, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_5)));
  }
  #endif
  
  TEST_F(ProfileInfoCacheTest,
         DontMigrateLegacyProfileNamesWithoutNewAvatarMenu) {
    switches::DisableNewAvatarMenuForTesting(CommandLine::ForCurrentProcess());
  
    EXPECT_EQ(0U, GetCache()->GetNumberOfProfiles());
  
    base::string16 name_1 = ASCIIToUTF16("Default Profile");
    base::FilePath path_1 = GetProfilePath("path_1");
    GetCache()->AddProfileToCache(path_1, name_1,
                                  base::string16(), 0, std::string());
    base::string16 name_2 = ASCIIToUTF16("First user");
    base::FilePath path_2 = GetProfilePath("path_2");
    GetCache()->AddProfileToCache(path_2, name_2,
                                  base::string16(), 1, std::string());
    base::string16 name_3 = ASCIIToUTF16("Lemonade");
    base::FilePath path_3 = GetProfilePath("path_3");
    GetCache()->AddProfileToCache(path_3, name_3,
                                  base::string16(), 2, std::string());
    base::string16 name_4 = ASCIIToUTF16("Batman");
    base::FilePath path_4 = GetProfilePath("path_4");
    GetCache()->AddProfileToCache(path_4, name_4,
                                  base::string16(), 3, std::string());
    EXPECT_EQ(4U, GetCache()->GetNumberOfProfiles());
  
    ResetCache();
  
    // Profile names should have been preserved.
    EXPECT_EQ(name_1, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_1)));
    EXPECT_EQ(name_2, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_2)));
    EXPECT_EQ(name_3, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_3)));
    EXPECT_EQ(name_4, GetCache()->GetNameOfProfileAtIndex(
        GetCache()->GetIndexOfProfileWithPath(path_4)));
  }
  
  