[cros] Profile image downloader is always reset after a download.

chrome/browser/chromeos/login/user_manager.cc

 // Copyright (c) 2011 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.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 29 matching lines @@
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/url_constants.h"
 #include "crypto/nss_util.h"
-#include "grit/theme_resources.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/png_codec.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "chrome/browser/chromeos/legacy_window_manager/wm_ipc.h"
 #endif
 
 using content::BrowserThread;
 
 namespace chromeos {
 
@@ skipping 215 matching lines @@
   users_.insert(users_.begin(), logged_in_user_);
 
   NotifyOnLogin();
 
   if (current_user_is_new_) {
     SetInitialUserImage(email);
   } else {
     // Download profile image if it's user image and see if it has changed.
     int image_index = logged_in_user_->image_index();
     if (image_index == User::kProfileImageIndex) {
+      InitDownloadedProfileImage();
       BrowserThread::PostDelayedTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&UserManager::DownloadProfileImage,
                      base::Unretained(this)),
           kProfileImageDownloadDelayMs);
     }
 
     int histogram_index = image_index;
     switch (image_index) {
@@ skipping 189 matching lines @@
       base::Bind(&UserManager::SaveUserImage,
                  base::Unretained(this), username));
 }
 
 void UserManager::SaveUserImageFromProfileImage(const std::string& username) {
   if (!downloaded_profile_image_.empty()) {
     // Profile image has already been downloaded, so save it to file right now.
     SaveUserImageInternal(username, User::kProfileImageIndex,
                           downloaded_profile_image_);
   } else {
-    // No profile image - use the default gray avatar.
-    SetUserImage(username, User::kProfileImageIndex,
-                 *ResourceBundle::GetSharedInstance().
-                     GetBitmapNamed(IDR_PROFILE_PICTURE_LOADING));
+    // No profile image - use the stub image (gray avatar).
+    SetUserImage(username, User::kProfileImageIndex, SkBitmap());
     SaveImageToLocalState(username, "", User::kProfileImageIndex, false);
   }
 }
 
 void UserManager::DownloadProfileImage() {
   if (profile_image_downloader_.get()) {
     // Another download is already in progress
     return;
   }
 
@@ skipping 100 matching lines @@
           // TODO(avayvod): Reading image path as a string is here for
           // backward compatibility.
           std::string image_path;
           base::DictionaryValue* image_properties;
           if (prefs_images->GetStringWithoutPathExpansion(email, &image_path)) {
             int image_id = User::kInvalidImageIndex;
             if (IsDefaultImagePath(image_path, &image_id)) {
               user->SetImage(GetDefaultImage(image_id), image_id);
             } else {
               int image_index = User::kExternalImageIndex;
-              // Until image has been loaded, use a stub.
-              user->SetImage(*ResourceBundle::GetSharedInstance().
-                                 GetBitmapNamed(IDR_PROFILE_PICTURE_LOADING),
-                             image_index);
+              // 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, 0,
                   base::Bind(&UserManager::SetUserImage,
                              base::Unretained(this), email, image_index));
             }
           } 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(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);
-              // Until image has been loaded, use a gray avatar.
-              user->SetImage(*ResourceBundle::GetSharedInstance().
-                                 GetBitmapNamed(IDR_PROFILE_PICTURE_LOADING),
-                             image_index);
+              // Until image has been loaded, use the stub image (gray avatar).
+              user->SetStubImage(image_index);
               if (!image_path.empty()) {
                 // Load user image asynchronously.
                 image_loader_->Start(
                     image_path, 0,
                     base::Bind(&UserManager::SetUserImage,
                                base::Unretained(this), email, image_index));
               }
             } else {
               NOTREACHED();
             }
@@ skipping 64 matching lines @@
                                int image_index,
                                const SkBitmap& 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 ||
            current_user_is_new_);
     bool image_changed = user->image_index() != User::kInvalidImageIndex;
-    user->SetImage(image, image_index);
-    // If it is the profile image of the current user, save it to
-    // |downloaded_profile_image_| so that it can be reused if the started
-    // download attempt fails.
-    if (image_index == User::kProfileImageIndex && user == logged_in_user_) {
-      downloaded_profile_image_ = image;
-      downloaded_profile_image_data_url_ = web_ui_util::GetImageDataUrl(image);
-    }
+    if (!image.empty())
+      user->SetImage(image, image_index);
+    else
+      user->SetStubImage(image_index);
+    // 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<UserManager>(this),
           content::Details<const User>(user));
     }
   }
 }
@@ skipping 67 matching lines @@
   base::DictionaryValue* image_properties = new base::DictionaryValue();
   image_properties->Set(kImagePathNodeName, new StringValue(image_path));
   image_properties->Set(kImageIndexNodeName,
                         new base::FundamentalValue(image_index));
   images_update->SetWithoutPathExpansion(username, image_properties);
   DVLOG(1) << "Saving path to user image in Local State.";
 
   NotifyLocalStateChanged();
 }
 
+void UserManager::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(downloaded_profile_image_);
+  }
+}
+
 void UserManager::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;
   }
 }
 
 void UserManager::UpdateOwnership(bool is_owner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 35 matching lines @@
   return ProfileManager::GetDefaultProfile();
 }
 
 std::string UserManager::GetCachedPictureURL() const {
   // Currently the profile picture URL is not cached on ChromeOS.
   return std::string();
 }
 
 void UserManager::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;
   std::string time_histogram_name;
   if (!success) {
     result = kDownloadFailure;
     time_histogram_name = kProfileDownloadFailureTime;
   } else if (downloader->GetProfilePicture().isNull()) {
     result = kDownloadDefault;
     time_histogram_name = kProfileDownloadDefaultTime;
   } else {
     result = kDownloadSuccess;
@@ skipping 34 matching lines @@
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED,
         content::Source<UserManager>(this),
         content::Details<const SkBitmap>(&downloaded_profile_image_));
   } else {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
         content::Source<UserManager>(this),
         content::NotificationService::NoDetails());
   }
-
-  profile_image_downloader_.reset();
 }
 
 User* UserManager::CreateUser(const std::string& email) const {
   User* user = new User(email);
   user->set_oauth_token_status(LoadUserOAuthStatus(email));
   // Used to determine whether user's display name is unique.
   ++display_name_count_[user->GetDisplayName()];
   return user;
 }
 
 }  // namespace chromeos