Add gaia_id to ProfileInfoCache.

chrome/browser/profiles/profile_info_cache_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 "chrome/browser/profiles/profile_info_cache_unittest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 115 matching lines @@
   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()->AddProfileToCache(profile_path, profile_name, std::string(),
+                                  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());
@@ skipping 20 matching lines @@
     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());
+                                std::string(), 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());
+  GetCache()->AddProfileToCache(path_2, name_2, std::string(), 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"),
+      GetProfilePath("path_1"), ASCIIToUTF16("name_1"), std::string(),
       base::string16(), 0, std::string());
   GetCache()->AddProfileToCache(
-      GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
+      GetProfilePath("path_2"), ASCIIToUTF16("name_2"), std::string(),
       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);
+  std::string new_gaia_id = "12345";
+  GetCache()->SetAuthInfoOfProfileAtIndex(1, new_gaia_id, new_user_name);
   EXPECT_EQ(new_user_name, GetCache()->GetUserNameOfProfileAtIndex(1));
+  EXPECT_EQ(new_gaia_id, GetCache()->GetGAIAIdOfProfileAtIndex(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());
+      GetProfilePath("path_a"), name_a, std::string(), base::string16(), 0,
+      std::string());
 
   base::string16 name_c = ASCIIToUTF16("cat");
   GetCache()->AddProfileToCache(
-      GetProfilePath("path_c"), name_c, base::string16(), 0, std::string());
+      GetProfilePath("path_c"), name_c, std::string(), 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());
+      GetProfilePath("path_b"), name_b, std::string(), 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());
+      std::string(), base::string16(), 0, std::string());
   GetCache()->AddProfileToCache(
       GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
-      base::string16(), 0, std::string());
+      std::string(), 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());
+      std::string(), 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());
+      std::string(), base::string16(), 0, std::string());
   base::string16 profile_name(ASCIIToUTF16("Person 2"));
   GetCache()->AddProfileToCache(
-      GetProfilePath("path_2"), profile_name, base::string16(), 0,
-      std::string());
+      GetProfilePath("path_2"), profile_name, std::string(), 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"));
@@ skipping 17 matching lines @@
   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());
+      std::string(), base::string16(), kDefaultAvatarIndex, std::string());
   GetCache()->AddProfileToCache(
       GetProfilePath("path_2"), ASCIIToUTF16("name_2"),
-      base::string16(), kDefaultAvatarIndex, std::string());
+      std::string(), 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));
@@ skipping 44 matching lines @@
   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());
+      std::string(), base::string16(), 0, std::string());
   gfx::Image gaia_image(gfx::test::CreateImage());
 
   GetCache()->SetGAIAPictureOfProfileAtIndex(0, &gaia_image);
 
   // Make sure everything has completed, and the file has been written to disk.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(gfx::test::IsEqual(
       gaia_image, *GetCache()->GetGAIAPictureOfProfileAtIndex(0)));
 
   ResetCache();
   // Try to get the GAIA picture. This should return NULL until the read from
   // disk is done.
   EXPECT_EQ(NULL, GetCache()->GetGAIAPictureOfProfileAtIndex(0));
   base::RunLoop().RunUntilIdle();
 
   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());
+      std::string(), 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());
+      GetProfilePath("path_1"), profile_name, std::string(), 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)));
@@ skipping 31 matching lines @@
     { "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, "");
+    GetCache()->AddProfileToCache(profile_path, profile_name, std::string(),
+                                  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;
   PrefService* local_state = g_browser_process->local_state();
@@ skipping 24 matching lines @@
 
   // // Make sure there are no avatars already on disk.
   const size_t kIconIndex = 0;
   base::FilePath icon_path =
       profiles::GetPathOfHighResAvatarAtIndex(kIconIndex);
   EXPECT_FALSE(base::PathExists(icon_path));
 
   EXPECT_EQ(0U, profile_info_cache.GetNumberOfProfiles());
   base::FilePath path_1 = GetProfilePath("path_1");
   profile_info_cache.AddProfileToCache(path_1, ASCIIToUTF16("name_1"),
-      base::string16(), kIconIndex, std::string());
+      std::string(), base::string16(), kIconIndex, std::string());
   EXPECT_EQ(1U, profile_info_cache.GetNumberOfProfiles());
   base::RunLoop().RunUntilIdle();
 
   // We haven't downloaded any high-res avatars yet.
   EXPECT_EQ(0U, profile_info_cache.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, profile_info_cache.avatar_images_downloads_in_progress_.size());
@@ skipping 35 matching lines @@
   EXPECT_FALSE(base::PathExists(icon_path));
 }
 
 TEST_F(ProfileInfoCacheTest, MigrateLegacyProfileNamesWithNewAvatarMenu) {
   switches::EnableNewAvatarMenuForTesting(
       base::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());
+                                std::string(), base::string16(), 0,
+                                std::string());
   base::FilePath path_2 = GetProfilePath("path_2");
   GetCache()->AddProfileToCache(path_2, ASCIIToUTF16("First user"),
-                                base::string16(), 1, std::string());
+                                std::string(), 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());
+                                std::string(), 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());
+                                std::string(), 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());
+                                std::string(), 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)));
@@ skipping 14 matching lines @@
 TEST_F(ProfileInfoCacheTest,
        DontMigrateLegacyProfileNamesWithoutNewAvatarMenu) {
   switches::DisableNewAvatarMenuForTesting(
       base::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());
+                                std::string(), 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());
+                                std::string(), 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());
+                                std::string(), 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());
+                                std::string(), 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)));
 }