Change default code flag to NewAvatarMenu.

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 104 matching lines @@
       AppendASCII(base_name);
 }
 
 void ProfileInfoCacheTest::ResetCache() {
   testing_profile_manager_.DeleteProfileInfoCache();
 }
 
 TEST_F(ProfileInfoCacheTest, AddProfiles) {
   EXPECT_EQ(0u, GetCache()->GetNumberOfProfiles());
 
+  // A bitmap for the high res avatar cache. Icon-sized bitmap of green pixels.
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(38, 31);
+  bitmap.eraseColor(SK_ColorGREEN);
+
   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));
+
+    ProfileAvatarDownloader avatar_downloader(
+        GetCache()->GetAvatarIconIndexOfProfileAtIndex(i),
+        profile_path, GetCache());
+    avatar_downloader.OnFetchComplete(
+        GURL("http://www.google.com/avatar.png"), &bitmap);
     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));
   }
 
@@ skipping 384 matching lines @@
   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(
       base::CommandLine::ForCurrentProcess());
 
-  EXPECT_EQ(0U, GetCache()->GetNumberOfProfiles());
+  // The TestingProfileManager's ProfileInfoCache auto-downloads avatars.
+  ProfileInfoCache profile_info_cache(g_browser_process->local_state(),
+      testing_profile_manager_.profile_manager()->user_data_dir());
+
+  // // Make sure there are no avatars already on disk.
+  const size_t kIconIndex = 0;
+  base::FilePath icon_path =
+      profiles::GetPathOfHighResAvatarAtIndex(kIconIndex);
+  EXPECT_TRUE(base::PathExists(icon_path));
+  EXPECT_TRUE(base::DeleteFile(icon_path, true));
+  EXPECT_FALSE(base::PathExists(icon_path));
+
+  EXPECT_EQ(0U, profile_info_cache.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());
+  profile_info_cache.AddProfileToCache(path_1, ASCIIToUTF16("name_1"),
+                                base::string16(), kIconIndex, std::string());

[noms (inactive), 2015/03/17 14:26:30]

nit: alignment here is whack :)

[Mike Lerman, 2015/03/18 19:29:48]

Done.

+  EXPECT_EQ(1U, profile_info_cache.GetNumberOfProfiles());
   base::RunLoop().RunUntilIdle();
 
   // We haven't downloaded any high-res avatars yet.
-  EXPECT_EQ(0U, GetCache()->cached_avatar_images_.size());
+  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, GetCache()->avatar_images_downloads_in_progress_.size());
+  EXPECT_EQ(1U, profile_info_cache.avatar_images_downloads_in_progress_.size());
 
-  EXPECT_FALSE(GetCache()->GetHighResAvatarOfProfileAtIndex(0));
+  EXPECT_FALSE(profile_info_cache.GetHighResAvatarOfProfileAtIndex(0));
 
   // Simulate downloading a high-res avatar.
-  const size_t kIconIndex = 0;
   ProfileAvatarDownloader avatar_downloader(
-      kIconIndex, GetCache()->GetPathOfProfileAtIndex(0), GetCache());
+      kIconIndex, profile_info_cache.GetPathOfProfileAtIndex(0),
+      &profile_info_cache);
 
   // 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);
 
   // Now the download should not be in progress anymore.
-  EXPECT_EQ(0U, GetCache()->avatar_images_downloads_in_progress_.size());
+  EXPECT_EQ(0U, profile_info_cache.avatar_images_downloads_in_progress_.size());
 
   std::string file_name =
       profiles::GetDefaultAvatarIconFileNameAtIndex(kIconIndex);
 
   // The file should have been cached and saved.
-  EXPECT_EQ(1U, GetCache()->cached_avatar_images_.size());
-  EXPECT_TRUE(GetCache()->GetHighResAvatarOfProfileAtIndex(0));
-  EXPECT_EQ(GetCache()->cached_avatar_images_[file_name],
-      GetCache()->GetHighResAvatarOfProfileAtIndex(0));
+  EXPECT_EQ(1U, profile_info_cache.cached_avatar_images_.size());
+  EXPECT_TRUE(profile_info_cache.GetHighResAvatarOfProfileAtIndex(0));
+  EXPECT_EQ(profile_info_cache.cached_avatar_images_[file_name],
+      profile_info_cache.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(
       base::CommandLine::ForCurrentProcess());
   EXPECT_EQ(0U, GetCache()->GetNumberOfProfiles());
@@ skipping 70 matching lines @@
   // 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)));
 }