[cros] Initial user image loading and repeated profile image loading fixes.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 58 matching lines @@
 // 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";
 
+// Index of the default image used as stub while the real user image is loading
+// from file and for the |kStubUser| user.
+const int kStubDefaultImageIndex = 0;
+
 // Delay betweeen user login and attempt to update user's profile image.
 const long kProfileImageDownloadDelayMs = 10000;
 
 base::LazyInstance<UserManager> g_user_manager(base::LINKER_INITIALIZED);
 
 // Used to handle the asynchronous response of deleting a cryptohome directory.
 class RemoveAttempt : public CryptohomeLibrary::Delegate {
  public:
   // Creates new remove attempt for the given user. Note, |delegate| can
   // be NULL.
@@ skipping 321 matching lines @@
       return static_cast<User::OAuthTokenStatus>(oauth_token_status);
     }
   }
 
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
 void UserManager::SaveUserDefaultImageIndex(const std::string& username,
                                             int image_index) {
   DCHECK(image_index >= 0 && image_index < kDefaultImagesCount);
-  SetUserImage(username, image_index,
-               *ResourceBundle::GetSharedInstance().
-                   GetBitmapNamed(kDefaultImageResources[image_index]));
+  SetUserImage(username, image_index, GetDefaultImage(image_index));
   SaveImageToLocalState(username, "", image_index, false);
 }
 
 void UserManager::SaveUserImage(const std::string& username,
                                 const SkBitmap& image) {
   SaveUserImageInternal(username, User::kExternalImageIndex, image);
 }
 
 void UserManager::SaveUserImageFromFile(const std::string& username,
                                         const FilePath& path) {
@@ skipping 11 matching lines @@
   } else {
     // No profile image - use the default gray avatar.
     SetUserImage(username, User::kProfileImageIndex,
                  *ResourceBundle::GetSharedInstance().
                      GetBitmapNamed(IDR_PROFILE_PICTURE_LOADING));
     SaveImageToLocalState(username, "", User::kProfileImageIndex, false);
   }
 }
 
 void UserManager::DownloadProfileImage() {
-  if (!profile_image_downloader_.get())
-    profile_image_downloader_.reset(new ProfileImageDownloader(this));
+  if (profile_image_downloader_.get()) {
+    // Another download is already in progress
+    return;
+  }
+  profile_image_downloader_.reset(new ProfileImageDownloader(this));
   profile_image_downloader_->Start();
   profile_image_load_start_time_ = base::Time::Now();
 }
 
 void UserManager::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                             base::Bind(&UserManager::CheckOwnership,
@@ skipping 80 matching lines @@
 
         if (prefs_images) {
           // Get account image path.
           // 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)) {
-              DCHECK(image_id >= 0 && image_id < kDefaultImagesCount);
-              int resource_id = kDefaultImageResources[image_id];
-              user->SetImage(*ResourceBundle::GetSharedInstance().
-                                 GetBitmapNamed(resource_id),
-                             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(GetDefaultImage(kStubDefaultImageIndex),
+                             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) {
-              int resource_id = kDefaultImageResources[image_index];
-              user->SetImage(*ResourceBundle::GetSharedInstance().
-                                 GetBitmapNamed(resource_id),
-                             image_index);
-            } else if (image_index == User::kProfileImageIndex &&
-                       image_path.empty()) {
-              // User has profile image as his picture but no profile image
-              // has been downloaded yet, so use a grey avatar for now.
-              user->SetImage(*ResourceBundle::GetSharedInstance().
-                                 GetBitmapNamed(IDR_PROFILE_PICTURE_LOADING),
-                             User::kProfileImageIndex);
+              user->SetImage(GetDefaultImage(image_index), image_index);
             } else if (image_index == User::kExternalImageIndex ||
                        image_index == User::kProfileImageIndex) {
-              // Load user image asynchronously.
-              image_loader_->Start(
-                  image_path, 0,
-                  base::Bind(&UserManager::SetUserImage,
-                             base::Unretained(this), email, image_index));
+              // 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 stub.
+              user->SetImage(GetDefaultImage(kStubDefaultImageIndex),
+                             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();
             }
           }
         }
       }
     }
   }
 }
 
 void UserManager::StubUserLoggedIn() {
   logged_in_user_ = &stub_user_;
-  SetUserImage(stub_user_.email(), 0,
-               *ResourceBundle::GetSharedInstance().
-                   GetBitmapNamed(kDefaultImageResources[0]));
+  stub_user_.SetImage(GetDefaultImage(kStubDefaultImageIndex),
+                      kStubDefaultImageIndex);
 }
 
 void UserManager::NotifyOnLogin() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::Source<UserManager>(this),
       content::Details<const User>(logged_in_user_));
 
   chromeos::input_method::InputMethodManager::GetInstance()->
       SetDeferImeStartup(false);
@@ skipping 30 matching lines @@
   // Choose a random default image.
   int image_id = base::RandInt(0, kDefaultImagesCount - 1);
   SaveUserDefaultImageIndex(username, image_id);
 }
 
 void UserManager::SetUserImage(const std::string& username,
                                int image_index,
                                const SkBitmap& image) {
   User* user = const_cast<User*>(FindUser(username));
   // User may have been removed by now.
-  if (user)
+  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 (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));
+    }
+  }
 }
 
 void UserManager::SaveUserImageInternal(const std::string& username,
                                         int image_index,
                                         const SkBitmap& image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetUserImage(username, image_index, image);
 
   FilePath image_path = GetImagePathForUser(username);
@@ skipping 57 matching lines @@
   DictionaryPrefUpdate images_update(local_state, 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));
   images_update->SetWithoutPathExpansion(username, image_properties);
   DVLOG(1) << "Saving path to user image in Local State.";
   local_state->ScheduleSavePersistentPrefs();
 
   NotifyLocalStateChanged();
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
-      content::Source<UserManager>(this),
-      content::Details<const User>(logged_in_user_));
 }
 
 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;
   }
 }
 
@@ skipping 54 matching lines @@
                               ProfileImageDownloader::kDownloadResultsCount);
 
     // This will persist |downloaded_profile_image_| to file.
     SaveUserImageFromProfileImage(logged_in_user().email());
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED,
       content::Source<UserManager>(this),
       content::Details<const SkBitmap>(&image));
+
+  profile_image_downloader_.reset();
 }
 
 void UserManager::OnDownloadFailure() {
   VLOG(1) << "Download of profile image for logged-in user failed.";
   UMA_HISTOGRAM_ENUMERATION("UserImageDownloadResult.LoggedIn",
                             ProfileImageDownloader::kDownloadFailure,
                             ProfileImageDownloader::kDownloadResultsCount);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_IMAGE_UPDATE_FAILED,
       content::Source<UserManager>(this),
       content::NotificationService::NoDetails());
+  profile_image_downloader_.reset();
 }
 
 void UserManager::OnDownloadDefaultImage() {
   VLOG(1) << "Logged-in user still has the default profile image.";
   UMA_HISTOGRAM_ENUMERATION("UserImageDownloadResult.LoggedIn",
                             ProfileImageDownloader::kDownloadDefault,
                             ProfileImageDownloader::kDownloadResultsCount);
   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(GetUserOAuthStatus(email));
   // Used to determine whether user's display name is unique.
   ++display_name_count_[user->GetDisplayName()];
   return user;
 }
 
 }  // namespace chromeos