Reland of: Change default code flag to NewAvatarMenu.

chrome/browser/profiles/profile_info_cache.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.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
@@ skipping 134 matching lines @@
 void DeleteBitmap(const base::FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   base::DeleteFile(image_path, false);
 }
 
 }  // namespace
 
 ProfileInfoCache::ProfileInfoCache(PrefService* prefs,
                                    const base::FilePath& user_data_dir)
     : prefs_(prefs),
-      user_data_dir_(user_data_dir) {
+      user_data_dir_(user_data_dir),
+      disable_avatar_download_for_testing_(false) {
   // Populate the cache
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   base::DictionaryValue* cache = update.Get();
   for (base::DictionaryValue::Iterator it(*cache);
        !it.IsAtEnd(); it.Advance()) {
     base::DictionaryValue* info = NULL;
     cache->GetDictionaryWithoutPathExpansion(it.key(), &info);
     base::string16 name;
     info->GetString(kNameKey, &name);
     sorted_keys_.insert(FindPositionForProfile(it.key(), name), it.key());
 
     bool using_default_name;
     if (!info->GetBoolean(kIsUsingDefaultNameKey, &using_default_name)) {
       // If the preference hasn't been set, and the name is default, assume
       // that the user hasn't done this on purpose.
       using_default_name = IsDefaultProfileName(name);
       info->SetBoolean(kIsUsingDefaultNameKey, using_default_name);
     }
 
     // For profiles that don't have the "using default avatar" state set yet,
     // assume it's the same as the "using default name" state.
     if (!info->HasKey(kIsUsingDefaultAvatarKey)) {
       info->SetBoolean(kIsUsingDefaultAvatarKey, using_default_name);
     }
   }
 
   // If needed, start downloading the high-res avatars and migrate any legacy
   // profile names.
-  if (switches::IsNewAvatarMenu())
+  if (switches::IsNewAvatarMenu() && !disable_avatar_download_for_testing_)
     MigrateLegacyProfileNamesAndDownloadAvatars();
 }
 
 ProfileInfoCache::~ProfileInfoCache() {
   STLDeleteContainerPairSecondPointers(
       cached_avatar_images_.begin(), cached_avatar_images_.end());
   STLDeleteContainerPairSecondPointers(
       avatar_images_downloads_in_progress_.begin(),
       avatar_images_downloads_in_progress_.end());
 }
@@ skipping 18 matching lines @@
   info->SetString(kSupervisedUserId, supervised_user_id);
   info->SetBoolean(kIsOmittedFromProfileListKey, !supervised_user_id.empty());
   info->SetBoolean(kProfileIsEphemeral, false);
   info->SetBoolean(kIsUsingDefaultNameKey, IsDefaultProfileName(name));
   // Assume newly created profiles use a default avatar.
   info->SetBoolean(kIsUsingDefaultAvatarKey, true);
   cache->SetWithoutPathExpansion(key, info.release());
 
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
 
-  if (switches::IsNewAvatarMenu())
+  if (switches::IsNewAvatarMenu() && !disable_avatar_download_for_testing_)
     DownloadHighResAvatarIfNeeded(icon_index, profile_path);
 
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
                     OnProfileAdded(profile_path));
 }
 
 void ProfileInfoCache::AddObserver(ProfileInfoCacheObserver* obs) {
   observer_list_.AddObserver(obs);
 }
@@ skipping 77 matching lines @@
 }
 
 base::string16 ProfileInfoCache::GetUserNameOfProfileAtIndex(
     size_t index) const {
   base::string16 user_name;
   GetInfoForProfileAtIndex(index)->GetString(kUserNameKey, &user_name);
   return user_name;
 }
 
 const gfx::Image& ProfileInfoCache::GetAvatarIconOfProfileAtIndex(
-    size_t index) const {
+    size_t index) {
   if (IsUsingGAIAPictureOfProfileAtIndex(index)) {
     const gfx::Image* image = GetGAIAPictureOfProfileAtIndex(index);
     if (image)
       return *image;
   }
 
   // Use the high resolution version of the avatar if it exists.
   if (switches::IsNewAvatarMenu()) {
     const gfx::Image* image = GetHighResAvatarOfProfileAtIndex(index);
     if (image)
@@ skipping 205 matching lines @@
                                                      size_t icon_index) {
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kAvatarIconKey,
       profiles::GetDefaultAvatarIconUrl(icon_index));
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
 
-  if (switches::IsNewAvatarMenu())
+  if (switches::IsNewAvatarMenu() && !disable_avatar_download_for_testing_)
     DownloadHighResAvatarIfNeeded(icon_index, profile_path);
 
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
                     OnProfileAvatarChanged(profile_path));
 }
 
 void ProfileInfoCache::SetIsOmittedProfileAtIndex(size_t index,
                                                   bool is_omitted) {
   if (IsOmittedProfileAtIndex(index) == is_omitted)
@@ skipping 301 matching lines @@
   registry->RegisterDictionaryPref(prefs::kProfileInfoCache);
 }
 
 void ProfileInfoCache::DownloadHighResAvatarIfNeeded(
     size_t icon_index,
     const base::FilePath& profile_path) {
   // Downloading is only supported on desktop.
 #if defined(OS_ANDROID) || defined(OS_IOS) || defined(OS_CHROMEOS)
   return;
 #endif
+  DCHECK(!disable_avatar_download_for_testing_);
 
   const base::FilePath& file_path =
       profiles::GetPathOfHighResAvatarAtIndex(icon_index);
   base::Closure callback =
       base::Bind(&ProfileInfoCache::DownloadHighResAvatar,
                  AsWeakPtr(),
                  icon_index,
                  profile_path);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(&RunCallbackIfFileMissing, file_path, callback));
@@ skipping 179 matching lines @@
     const base::FilePath& profile_path,
     const std::string& key,
     const base::FilePath& image_path) const {
   // If the picture is already loaded then use it.
   if (cached_avatar_images_.count(key)) {
     if (cached_avatar_images_[key]->IsEmpty())
       return NULL;
     return cached_avatar_images_[key];
   }
 
+  // Don't download the image if downloading is disabled for tests.
+  if (disable_avatar_download_for_testing_)
+    return NULL;
+
   // If the picture is already being loaded then don't try loading it again.
   if (cached_avatar_images_loading_[key])
     return NULL;
   cached_avatar_images_loading_[key] = true;
 
   gfx::Image** image = new gfx::Image*;
   BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReadBitmap, image_path, image),
       base::Bind(&ProfileInfoCache::OnAvatarPictureLoaded,
           const_cast<ProfileInfoCache*>(this)->AsWeakPtr(),
@@ skipping 85 matching lines @@
   std::vector<base::FilePath>::const_iterator it;
   for (it = profiles_to_rename.begin(); it != profiles_to_rename.end(); ++it) {
     size_t profile_index = GetIndexOfProfileWithPath(*it);
     SetProfileIsUsingDefaultNameAtIndex(profile_index, true);
     // This will assign a new "Person %d" type name and re-sort the cache.
     SetNameOfProfileAtIndex(profile_index, ChooseNameForNewProfile(
         GetAvatarIconIndexOfProfileAtIndex(profile_index)));
   }
 #endif
 }