1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_USERS_AVATAR_USER_IMAGE_MANAGER_IMPL_H_ 6 #define CHROME_BROWSER_CHROMEOS_LOGIN_USERS_AVATAR_USER_IMAGE_MANAGER_IMPL_H_ 7 8 #include <map> 9 #include <set> 10 #include <string> 11 12 #include "base/basictypes.h" 13 #include "base/compiler_specific.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/memory/weak_ptr.h" 17 #include "base/time/time.h" 18 #include "base/timer/timer.h" 19 #include "base/values.h" 20 #include "chrome/browser/chromeos/login/users/avatar/user_image_loader.h" 21 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager.h" 22 #include "chrome/browser/chromeos/login/users/user.h" 23 #include "chrome/browser/profiles/profile_downloader_delegate.h" 24 #include "ui/gfx/image/image_skia.h" 25 26 class ProfileDownloader; 27 class UserImage; 28 29 namespace base { 30 class FilePath; 31 class SequencedTaskRunner; 32 } 33 34 namespace chromeos { 35 36 class UserImageSyncObserver; 37 class UserManager; 38 39 class UserImageManagerImpl 40 : public UserImageManager, 41 public ProfileDownloaderDelegate { 42 public: 43 // UserImageManager: 44 UserImageManagerImpl(const std::string& user_id, 45 UserManager* user_manager); 46 virtual ~UserImageManagerImpl(); 47 48 virtual void LoadUserImage() OVERRIDE; 49 virtual void UserLoggedIn(bool user_is_new, bool user_is_local) OVERRIDE; 50 virtual void SaveUserDefaultImageIndex(int default_image_index) OVERRIDE; 51 virtual void SaveUserImage(const UserImage& user_image) OVERRIDE; 52 virtual void SaveUserImageFromFile(const base::FilePath& path) OVERRIDE; 53 virtual void SaveUserImageFromProfileImage() OVERRIDE; 54 virtual void DeleteUserImage() OVERRIDE; 55 virtual void DownloadProfileImage(const std::string& reason) OVERRIDE; 56 virtual const gfx::ImageSkia& DownloadedProfileImage() const OVERRIDE; 57 virtual UserImageSyncObserver* GetSyncObserver() const OVERRIDE; 58 virtual void Shutdown() OVERRIDE; 59 60 virtual void OnExternalDataSet(const std::string& policy) OVERRIDE; 61 virtual void OnExternalDataCleared(const std::string& policy) OVERRIDE; 62 virtual void OnExternalDataFetched(const std::string& policy, 63 scoped_ptr<std::string> data) OVERRIDE; 64 65 static void IgnoreProfileDataDownloadDelayForTesting(); 66 67 private: 68 friend class UserImageManagerTest; 69 70 // Every image load or update is encapsulated by a Job. Whenever an image load 71 // or update is requested for a user, the Job currently running for that user 72 // (if any) is canceled. This ensures that at most one Job is running per user 73 // at any given time. There are two further guarantees: 74 // 75 // * Changes to User objects and local state are performed on the thread that 76 // |this| runs on. 77 // * File writes and deletions are performed via |background_task_runner_|. 78 // 79 // With the above, it is guaranteed that any changes made by a canceled Job 80 // cannot race against against changes made by the superseding Job. 81 class Job; 82 83 // ProfileDownloaderDelegate: 84 virtual bool NeedsProfilePicture() const OVERRIDE; 85 virtual int GetDesiredImageSideLength() const OVERRIDE; 86 virtual Profile* GetBrowserProfile() OVERRIDE; 87 virtual std::string GetCachedPictureURL() const OVERRIDE; 88 virtual void OnProfileDownloadSuccess(ProfileDownloader* downloader) OVERRIDE; 89 virtual void OnProfileDownloadFailure( 90 ProfileDownloader* downloader, 91 ProfileDownloaderDelegate::FailureReason reason) OVERRIDE; 92 93 // Returns true if the user image for the user is managed by 94 // policy and the user is not allowed to change it. 95 bool IsUserImageManaged() const; 96 97 // Randomly chooses one of the default images for the specified user, sends a 98 // LOGIN_USER_IMAGE_CHANGED notification and updates local state. 99 void SetInitialUserImage(); 100 101 // Initializes the |downloaded_profile_image_| for the currently logged-in 102 // user to a profile image that had been downloaded and saved before if such 103 // a saved image is available and no updated image has been downloaded yet. 104 void TryToInitDownloadedProfileImage(); 105 106 // Returns true if the profile image needs to be downloaded. This is the case 107 // when a GAIA user is logged in and at least one of the following applies: 108 // * The profile image has explicitly been requested by a call to 109 // DownloadProfileImage() and has not been successfully downloaded since. 110 // * The user's user image is the profile image. 111 bool NeedProfileImage() const; 112 113 // Downloads the profile data for the currently logged-in user. The user's 114 // full name and, if NeedProfileImage() is true, the profile image are 115 // downloaded. |reason| is an arbitrary string (used to report UMA histograms 116 // with download times). 117 void DownloadProfileData(const std::string& reason); 118 119 // Removes ther user from the dictionary |prefs_dict_root| in 120 // local state and deletes the image file that the dictionary 121 // referenced for that user. 122 void DeleteUserImageAndLocalStateEntry(const char* prefs_dict_root); 123 124 // Called when a Job updates the copy of the user image held in 125 // memory. Allows |this| to update |downloaded_profile_image_| and 126 // send a NOTIFICATION_LOGIN_USER_IMAGE_CHANGED notification. 127 void OnJobChangedUserImage(); 128 129 // Called when a Job for the user finishes. If a migration was 130 // required for the user, the migration is now complete and the old 131 // image file for that user, if any, is deleted. 132 void OnJobDone(); 133 134 // Completes migration by removing the user from the old prefs 135 // dictionary. 136 void UpdateLocalStateAfterMigration(); 137 138 // Create a sync observer if a user is logged in, the user's user image is 139 // allowed to be synced and no sync observer exists yet. 140 void TryToCreateImageSyncObserver(); 141 142 // Returns immutable version of user with |user_id_|. 143 const User* GetUser() const; 144 145 // Returns mutable version of user with |user_id_|. 146 User* GetUserAndModify() const; 147 148 // Returns true if user with |user_id_| is logged in and a regular user. 149 bool IsUserLoggedInAndRegular() const; 150 151 // The user manager. 152 UserManager* user_manager_; 153 154 // Loader for JPEG user images. 155 scoped_refptr<UserImageLoader> image_loader_; 156 157 // Unsafe loader instance for all user images formats. 158 scoped_refptr<UserImageLoader> unsafe_image_loader_; 159 160 // Whether the |profile_downloader_| is downloading the profile image for the 161 // currently logged-in user (and not just the full name). Only valid when a 162 // download is currently in progress. 163 bool downloading_profile_image_; 164 165 // Download reason given to DownloadProfileImage(), used for UMA histograms. 166 // Only valid when a download is currently in progress and 167 // |downloading_profile_image_| is true. 168 std::string profile_image_download_reason_; 169 170 // Time when the profile image download started. Only valid when a download is 171 // currently in progress and |downloading_profile_image_| is true. 172 base::TimeTicks profile_image_load_start_time_; 173 174 // Downloader for the user's profile data. NULL when no download is 175 // currently in progress. 176 scoped_ptr<ProfileDownloader> profile_downloader_; 177 178 // The currently logged-in user's downloaded profile image, if successfully 179 // downloaded or initialized from a previously downloaded and saved image. 180 gfx::ImageSkia downloaded_profile_image_; 181 182 // Data URL corresponding to |downloaded_profile_image_|. Empty if no 183 // |downloaded_profile_image_| is currently available. 184 std::string downloaded_profile_image_data_url_; 185 186 // URL from which |downloaded_profile_image_| was downloaded. Empty if no 187 // |downloaded_profile_image_| is currently available. 188 GURL profile_image_url_; 189 190 // Whether a download of the currently logged-in user's profile image has been 191 // explicitly requested by a call to DownloadProfileImage() and has not been 192 // satisfied by a successful download yet. 193 bool profile_image_requested_; 194 195 // Timer used to start a profile data download shortly after login and to 196 // restart the download after network errors. 197 base::OneShotTimer<UserImageManagerImpl> profile_download_one_shot_timer_; 198 199 // Timer used to periodically start a profile data, ensuring the profile data 200 // stays up to date. 201 base::RepeatingTimer<UserImageManagerImpl> profile_download_periodic_timer_; 202 203 // Sync observer for the currently logged-in user. 204 scoped_ptr<UserImageSyncObserver> user_image_sync_observer_; 205 206 // Background task runner on which Jobs perform file I/O and the image 207 // decoders run. 208 scoped_refptr<base::SequencedTaskRunner> background_task_runner_; 209 210 // The currently running job. 211 scoped_ptr<Job> job_; 212 213 bool has_managed_image_; 214 bool user_needs_migration_; 215 216 base::WeakPtrFactory<UserImageManagerImpl> weak_factory_; 217 218 DISALLOW_COPY_AND_ASSIGN(UserImageManagerImpl); 219 }; 220 221 } // namespace chromeos 222 223 #endif // CHROME_BROWSER_CHROMEOS_LOGIN_USERS_AVATAR_USER_IMAGE_MANAGER_IMPL_H_ 224