[cros] Cache the URL of user's G+ profile photo to prevent redundant downloads.

chrome/browser/chromeos/login/user_manager_impl.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/chromeos/login/user_manager_impl.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 56 matching lines @@
 // Incognito user is represented by an empty string (since some code already
 // depends on that and it's hard to figure out what).
 const char kGuestUser[] = "";
 
 // Stub user email (for test paths).
 const char kStubUser[] = "stub-user@example.com";
 
 // Names of nodes with info about user image.
 const char kImagePathNodeName[] = "path";
 const char kImageIndexNodeName[] = "index";
+const char kImageURLNodeName[] = "url";
 
 const char kWallpaperTypeNodeName[] = "type";
 const char kWallpaperIndexNodeName[] = "index";
 
 const int kThumbnailWidth = 128;
 const int kThumbnailHeight = 80;
 
 // Index of the default image used for the |kStubUser| user.
 const int kStubDefaultImageIndex = 0;
 
@@ skipping 496 matching lines @@
 
 std::string UserManagerImpl::GetUserDisplayEmail(
     const std::string& username) const {
   const User* user = FindUser(username);
   return user ? user->display_email() : username;
 }
 
 void UserManagerImpl::SaveUserDefaultImageIndex(const std::string& username,
                                                 int image_index) {
   DCHECK(image_index >= 0 && image_index < kDefaultImagesCount);
-  SetUserImage(username, image_index, UserImage(GetDefaultImage(image_index)));
-  SaveImageToLocalState(username, "", image_index, false);
+  SetUserImage(username, image_index, GURL(),
+               UserImage(GetDefaultImage(image_index)));
+  SaveImageToLocalState(username, "", image_index, GURL(), false);
 }
 
 void UserManagerImpl::SaveUserImage(const std::string& username,
                                     const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SaveUserImageInternal(username, User::kExternalImageIndex, user_image);
+  SaveUserImageInternal(username, User::kExternalImageIndex,
+                        GURL(), user_image);
 }
 
 void UserManagerImpl::SetLoggedInUserCustomWallpaperLayout(
     ash::WallpaperLayout layout) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(bshe): We current disabled the customized wallpaper feature for
   // Ephemeral user. As we dont want to keep a copy of customized wallpaper in
   // memory. Need a smarter way to solve this.
   if (IsCurrentUserEphemeral())
@@ skipping 28 matching lines @@
       base::Bind(&UserManagerImpl::SaveUserWallpaperInternal,
                  base::Unretained(this), username, layout, User::CUSTOMIZED,
                  delegate));
 }
 
 void UserManagerImpl::SaveUserImageFromProfileImage(
     const std::string& username) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!downloaded_profile_image_.empty()) {
     // Profile image has already been downloaded, so save it to file right now.
-    SaveUserImageInternal(username, User::kProfileImageIndex,
+    DCHECK(profile_image_url_.is_valid());
+    SaveUserImageInternal(username,
+                          User::kProfileImageIndex, profile_image_url_,
                           UserImage(downloaded_profile_image_));
   } else {
     // No profile image - use the stub image (gray avatar).
-    SetUserImage(username, User::kProfileImageIndex, UserImage(SkBitmap()));
-    SaveImageToLocalState(username, "", User::kProfileImageIndex, false);
+    SetUserImage(username, User::kProfileImageIndex,
+                 GURL(), UserImage(SkBitmap()));
+    SaveImageToLocalState(username, "", User::kProfileImageIndex,
+                          GURL(), false);
   }
 }
 
 void UserManagerImpl::DownloadProfileImage(const std::string& reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (profile_image_downloader_.get()) {
     // Another download is already in progress
     return;
   }
@@ skipping 180 matching lines @@
               user->SetImage(UserImage(GetDefaultImage(image_id)), image_id);
             } else {
               int image_index = User::kExternalImageIndex;
               // Until image has been loaded, use the stub image.
               user->SetStubImage(image_index);
               DCHECK(!image_path.empty());
               // Load user image asynchronously.
               image_loader_->Start(
                   image_path, user_image_size, true,
                   base::Bind(&UserManagerImpl::SetUserImage,
-                             base::Unretained(this), email, image_index));
+                             base::Unretained(this),
+                             email, image_index, GURL()));
             }
           } else if (prefs_images->GetDictionaryWithoutPathExpansion(
                          email, &image_properties)) {
             int image_index = User::kInvalidImageIndex;
             image_properties->GetString(kImagePathNodeName, &image_path);
             image_properties->GetInteger(kImageIndexNodeName, &image_index);
             if (image_index >= 0 && image_index < kDefaultImagesCount) {
               user->SetImage(UserImage(GetDefaultImage(image_index)),
                              image_index);
             } else if (image_index == User::kExternalImageIndex ||
                        image_index == User::kProfileImageIndex) {
               // Path may be empty for profile images (meaning that the image
               // hasn't been downloaded for the first time yet, in which case a
               // download will be scheduled for |kProfileImageDownloadDelayMs|
               // after user logs in).
               DCHECK(!image_path.empty() ||
                      image_index == User::kProfileImageIndex);
+              std::string image_url;
+              image_properties->GetString(kImageURLNodeName, &image_url);
+              GURL image_gurl(image_url);
               // Until image has been loaded, use the stub image (gray avatar).
               user->SetStubImage(image_index);
+              user->SetImageURL(image_gurl);
               if (!image_path.empty()) {
                 // Load user image asynchronously.
                 image_loader_->Start(
                     image_path, user_image_size, true,
                     base::Bind(&UserManagerImpl::SetUserImage,
-                               base::Unretained(this), email, image_index));
+                               base::Unretained(this),
+                               email, image_index, image_gurl));
               }
             } else {
               NOTREACHED();
             }
           }
         }
 
         string16 display_name;
         if (prefs_display_names &&
             prefs_display_names->GetStringWithoutPathExpansion(
@@ skipping 201 matching lines @@
 }
 
 void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
     User::WallpaperType type,
     int index) {
   SaveUserWallpaperProperties(GetLoggedInUser().email(), type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
                                    int image_index,
+                                   const GURL& image_url,
                                    const UserImage& user_image) {
   User* user = const_cast<User*>(FindUser(username));
   // User may have been removed by now.
   if (user) {
     // For existing users, a valid image index should have been set upon loading
     // them from Local State.
     DCHECK(user->image_index() != User::kInvalidImageIndex ||
            is_current_user_new_);
     bool image_changed = user->image_index() != User::kInvalidImageIndex;
     if (!user_image.image().empty())
       user->SetImage(user_image, image_index);
     else
       user->SetStubImage(image_index);
+    user->SetImageURL(image_url);
     // For the logged-in user with a profile picture, initialize
     // |downloaded_profile_picture_|.
     if (user == logged_in_user_ && image_index == User::kProfileImageIndex)
       InitDownloadedProfileImage();
     if (image_changed) {
       // Unless this is first-time setting with |SetInitialUserImage|,
       // send a notification about image change.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
           content::Source<UserManagerImpl>(this),
@@ skipping 48 matching lines @@
   base::DictionaryValue* wallpaper_properties = new base::DictionaryValue();
   wallpaper_properties->Set(kWallpaperTypeNodeName,
                             new base::FundamentalValue(type));
   wallpaper_properties->Set(kWallpaperIndexNodeName,
                             new base::FundamentalValue(index));
   wallpaper_update->SetWithoutPathExpansion(username, wallpaper_properties);
 }
 
 void UserManagerImpl::SaveUserImageInternal(const std::string& username,
                                             int image_index,
+                                            const GURL& image_url,
                                             const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  SetUserImage(username, image_index, user_image);
+  SetUserImage(username, image_index, image_url, user_image);
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
 
   FilePath image_path = GetImagePathForUser(username);
   DVLOG(1) << "Saving user image to " << image_path.value();
 
   last_image_set_async_ = true;
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToFile,
                  base::Unretained(this),
-                 username, user_image, image_path, image_index));
+                 username, user_image, image_path, image_index, image_url));
 }
 
 void UserManagerImpl::SaveUserWallpaperInternal(const std::string& username,
                                                 ash::WallpaperLayout layout,
                                                 User::WallpaperType type,
                                                 WallpaperDelegate* delegate,
                                                 const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const SkBitmap& wallpaper = user_image.image();
@@ skipping 76 matching lines @@
   if (IsEphemeralUser(username))
     return;
 
   FilePath thumbnail_path = GetWallpaperPathForUser(username, true);
   SaveBitmapToFile(UserImage(thumbnail), thumbnail_path);
 }
 
 void UserManagerImpl::SaveImageToFile(const std::string& username,
                                       const UserImage& user_image,
                                       const FilePath& image_path,
-                                      int image_index) {
+                                      int image_index,
+                                      const GURL& image_url) {
   if (!SaveBitmapToFile(user_image, image_path))
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveImageToLocalState,
                  base::Unretained(this),
-                 username, image_path.value(), image_index, true));
+                 username, image_path.value(), image_index, image_url, true));
 }
 
 void UserManagerImpl::SaveWallpaperToFile(const std::string& username,
                                           const SkBitmap& wallpaper,
                                           const FilePath& wallpaper_path,
                                           ash::WallpaperLayout layout,
                                           User::WallpaperType type) {
   // TODO(bshe): We should save the original file unchanged instead of
   // re-encoding it and saving it.
   if (!SaveBitmapToFile(UserImage(wallpaper), wallpaper_path))
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UserManagerImpl::SaveWallpaperToLocalState,
                  base::Unretained(this),
                  username, wallpaper_path.value(), layout, type));
 }
 
 void UserManagerImpl::SaveImageToLocalState(const std::string& username,
                                             const std::string& image_path,
                                             int image_index,
+                                            const GURL& image_url,
                                             bool is_async) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
 
   // TODO(ivankr): use unique filenames for user images each time
   // a new image is set so that only the last image update is saved
   // to Local State and notified.
   if (is_async && !last_image_set_async_) {
     DVLOG(1) << "Ignoring saved image because it has changed";
     return;
   } else if (!is_async) {
     // Reset the async image save flag if called directly from the UI thread.
     last_image_set_async_ = false;
   }
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate images_update(local_state, UserManager::kUserImages);
   base::DictionaryValue* image_properties = new base::DictionaryValue();
   image_properties->Set(kImagePathNodeName, new StringValue(image_path));
   image_properties->Set(kImageIndexNodeName,
                         new base::FundamentalValue(image_index));
+  if (!image_url.is_empty()) {
+    image_properties->Set(kImageURLNodeName,
+                          new StringValue(image_url.spec()));
+  } else {
+    image_properties->Remove(kImageURLNodeName, NULL);
+  }
   images_update->SetWithoutPathExpansion(username, image_properties);
   DVLOG(1) << "Saving path to user image in Local State.";
 
   NotifyLocalStateChanged();
 }
 
 void UserManagerImpl::SaveWallpaperToLocalState(const std::string& username,
     const std::string& wallpaper_path,
     ash::WallpaperLayout layout,
     User::WallpaperType type) {
@@ skipping 25 matching lines @@
   return true;
 }
 
 void UserManagerImpl::InitDownloadedProfileImage() {
   DCHECK(logged_in_user_);
   if (downloaded_profile_image_.empty() && !logged_in_user_->image_is_stub()) {
     VLOG(1) << "Profile image initialized";
     downloaded_profile_image_ = logged_in_user_->image();
     downloaded_profile_image_data_url_ =
         web_ui_util::GetImageDataUrl(gfx::ImageSkia(downloaded_profile_image_));
+    profile_image_url_ = logged_in_user_->image_url();
   }
 }
 
 void UserManagerImpl::DeleteUserImage(const FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::Delete(image_path, false)) {
     LOG(ERROR) << "Failed to remove user image.";
     return;
   }
 }
@@ skipping 21 matching lines @@
 
   // UserManagerImpl should be accessed only on UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&UserManagerImpl::UpdateOwnership,
                  base::Unretained(this),
                  is_owner));
 }
 
+// ProfileDownloaderDelegate override.
 int UserManagerImpl::GetDesiredImageSideLength() const {
   return GetCurrentUserImageSize();
 }
 
+// ProfileDownloaderDelegate override.
+std::string UserManagerImpl::GetCachedPictureURL() const {
+  return profile_image_url_.spec();
+}
+
 Profile* UserManagerImpl::GetBrowserProfile() {
   return ProfileManager::GetDefaultProfile();
 }
 
-std::string UserManagerImpl::GetCachedPictureURL() const {
-  // Currently the profile picture URL is not cached on ChromeOS.
-  return std::string();
-}
-
 void UserManagerImpl::OnDownloadComplete(ProfileDownloader* downloader,
                                          bool success) {
   // Make sure that |ProfileDownloader| gets deleted after return.
   scoped_ptr<ProfileDownloader> profile_image_downloader(
       profile_image_downloader_.release());
   DCHECK(profile_image_downloader.get() == downloader);
 
   ProfileDownloadResult result;
   if (!success) {
     SaveUserDisplayName(GetLoggedInUser().email(),
@@ skipping 23 matching lines @@
     // Check if this image is not the same as already downloaded.
     std::string new_image_data_url =
         web_ui_util::GetImageDataUrl(gfx::ImageSkia(
         downloader->GetProfilePicture()));
     if (!downloaded_profile_image_data_url_.empty() &&
         new_image_data_url == downloaded_profile_image_data_url_)
       return;
 
     downloaded_profile_image_data_url_ = new_image_data_url;
     downloaded_profile_image_ = downloader->GetProfilePicture();
+    profile_image_url_ = GURL(downloader->GetProfilePictureURL());
 
     if (GetLoggedInUser().image_index() == User::kProfileImageIndex) {
       VLOG(1) << "Updating profile image for logged-in user";
       UMA_HISTOGRAM_ENUMERATION("UserImage.ProfileDownloadResult",
                                 kDownloadSuccessChanged,
                                 kDownloadResultsCount);
 
       // This will persist |downloaded_profile_image_| to file.
       SaveUserImageFromProfileImage(GetLoggedInUser().email());
     }
@@ skipping 86 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos