[Profiles] Download high-res avatars using the --new-profile-management flag

chrome/browser/profiles/profile_info_cache.h

 // 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.
 
 #ifndef CHROME_BROWSER_PROFILES_PROFILE_INFO_CACHE_H_
 #define CHROME_BROWSER_PROFILES_PROFILE_INFO_CACHE_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 10 matching lines @@
 namespace gfx {
 class Image;
 }
 
 namespace base {
 class DictionaryValue;
 }
 
 class PrefService;
 class PrefRegistrySimple;
+class ProfileAvatarDownloader;
 
 // This class saves various information about profiles to local preferences.
 // This cache can be used to display a list of profiles without having to
 // actually load the profiles from disk.
 class ProfileInfoCache : public ProfileInfoInterface,
                          public base::SupportsWeakPtr<ProfileInfoCache> {
  public:
   ProfileInfoCache(PrefService* prefs, const base::FilePath& user_data_dir);
   virtual ~ProfileInfoCache();
 
@@ skipping 87 matching lines @@
 
   // Gets all names of profiles associated with this instance of Chrome.
   // Because this method will be called during uninstall, before the creation
   // of the ProfileManager, it reads directly from the local state preferences,
   // rather than going through the ProfileInfoCache object.
   static std::vector<base::string16> GetProfileNames();
 
   // Register cache related preferences in Local State.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
+  // Starts downloading the high res avatar at index |icon_index|.
+  // Takes ownership of |avatar_dowloader|, which will be deleted either
+  // when the download completes and OnAvatarPictureSaved is called, or when
+  // the ProfileInfoCache is destroyed.
+  void DownloadHighResAvatar(ProfileAvatarDownloader* avatar_downloader,
+                             size_t icon_index);
+
+  // Saves the avatar |image| at |image_path|. This is used both for the
+  // GAIA profile pictures and the ProfileAvatarDownloader that is used to
+  // download the high res avatars.
+  void SaveAvatarImageAtPath(const gfx::Image* image,
+                             const std::string& key,
+                             const base::FilePath& image_path);
+
   void AddObserver(ProfileInfoCacheObserver* obs);
   void RemoveObserver(ProfileInfoCacheObserver* obs);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(ProfileInfoCacheTest, DownloadHighResAvatarTest);
+
   const base::DictionaryValue* GetInfoForProfileAtIndex(size_t index) const;
   // Saves the profile info to a cache and takes ownership of |info|.
   // Currently the only information that is cached is the profile's name,
   // user name, and avatar icon.
   void SetInfoQuietlyForProfileAtIndex(size_t index,
                                        base::DictionaryValue* info);
   void SetInfoForProfileAtIndex(size_t index, base::DictionaryValue* info);
   std::string CacheKeyFromProfilePath(const base::FilePath& profile_path) const;
   std::vector<std::string>::iterator FindPositionForProfile(
       const std::string& search_key,
       const base::string16& search_name);
 
   // Returns true if the given icon index is not in use by another profie.
   bool IconIndexIsUnique(size_t icon_index) const;
 
   // Tries to find an icon index that satisfies all the given conditions.
   // Returns true if an icon was found, false otherwise.
   bool ChooseAvatarIconIndexForNewProfile(bool allow_generic_icon,
                                           bool must_be_unique,
                                           size_t* out_icon_index) const;
 
   // Updates the position of the profile at the given index so that the list
   // of profiles is still sorted.
   void UpdateSortForProfileIndex(size_t index);
 
   // Loads or uses an already loaded high resolution image of the
   // generic profile avatar.
   const gfx::Image* GetHighResAvatarOfProfileAtIndex(size_t index) const;
 
+  // Returns the decoded image at |image_path|. Used both by the GAIA profile
+  // image and the high res avatars.
   const gfx::Image* LoadAvatarPictureFromPath(
       const std::string& key,
       const base::FilePath& image_path) const;
+
+  // Called when the picture given by |key| has been loaded from disk and
+  // decoded into |image|.
   void OnAvatarPictureLoaded(const std::string& key,
                              gfx::Image** image) const;
-  void OnGAIAPictureSaved(const base::FilePath& path, bool* success) const;
+  // Called when the picture given by |file_name| has been saved to disk.
+  // Used both for the GAIA profile picture and the high res avatar files.
+  void OnAvatarPictureSaved(const std::string& file_name, bool* success);
 
   PrefService* prefs_;
   std::vector<std::string> sorted_keys_;
   base::FilePath user_data_dir_;
 
   ObserverList<ProfileInfoCacheObserver> observer_list_;
 
   // A cache of gaia/high res avatar profile pictures. This cache is updated
   // lazily so it needs to be mutable.
   mutable std::map<std::string, gfx::Image*> cached_avatar_images_;
-  // Marks a profile picture as loading. This prevents a picture from
+  // Marks a profile picture as loading from disk. This prevents a picture from
   // loading multiple times.
   mutable std::map<std::string, bool> cached_avatar_images_loading_;
 
+  // Map of profile pictures currently being downloaded from the remote
+  // location and the ProfileAvatarDownloader instances downloading them.
+  // This prevents a picture from being downloaded multiple times. The
+  // ProfileAvatarDownloader pointers are deleted when the download completes or
+  // when the ProfileInfoCache is destroyed.
+  mutable std::map<std::string, ProfileAvatarDownloader*>
+      avatar_images_downloads_in_progress_;
+
   DISALLOW_COPY_AND_ASSIGN(ProfileInfoCache);
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_INFO_CACHE_H_