Delete user image when user is removed.

chrome/browser/chromeos/login/user_manager.cc

 // Copyright (c) 2010 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 "app/resource_bundle.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 81 matching lines @@
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableFunction(&SavePathToLocalState,
                           username, image_path.value()));
 }
 
+// Deletes user's image file. Runs on FILE thread.
+void 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;
+  }
+}
+
 // Checks if given path is one of the default ones. If it is, returns true
 // and its index in kDefaultImageNames through |image_id|. If not, returns
 // false.
 bool IsDefaultImagePath(const std::string& path, size_t* image_id) {
   DCHECK(image_id);
   for (size_t i = 0; i < arraysize(kDefaultImageNames); ++i) {
     if (path == kDefaultImageNames[i]) {
       *image_id = i;
       return true;
     }
@@ skipping 143 matching lines @@
   NotifyOnLogin();
 }
 
 void UserManager::RemoveUser(const std::string& email) {
   // Get a copy of the current users.
   std::vector<User> users = GetUsers();
 
   // Clear the prefs view of the users.
   PrefService* prefs = g_browser_process->local_state();
   ListValue* prefs_users = prefs->GetMutableList(kLoggedInUsers);
+  DCHECK(prefs_users);
   prefs_users->Clear();
 
   for (std::vector<User>::iterator it = users.begin();
        it != users.end();
        ++it) {
     std::string user_email = it->email();
     // Skip user that we would like to delete.
     if (email != user_email)
       prefs_users->Append(Value::CreateStringValue(user_email));
   }
+
+  DictionaryValue* prefs_images = prefs->GetMutableDictionary(kUserImages);
+  DCHECK(prefs_images);
+  std::string image_path_string;
+  prefs_images->GetStringWithoutPathExpansion(email, &image_path_string);
+  prefs_images->RemoveWithoutPathExpansion(email, NULL);
+
   prefs->SavePersistentPrefs();
+
+  size_t default_image_id;
+  if (!IsDefaultImagePath(image_path_string, &default_image_id)) {
+    FilePath image_path(image_path_string);
+    BrowserThread::PostTask(
+        BrowserThread::FILE,
+        FROM_HERE,
+        NewRunnableFunction(&DeleteUserImage,
+                            image_path));
+  }
 }
 
 bool UserManager::IsKnownUser(const std::string& email) {
   std::vector<User> users = GetUsers();
   for (std::vector<User>::iterator it = users.begin();
        it < users.end();
        ++it) {
     if (it->email() == email)
       return true;
   }
 
   return false;
 }
 
 void UserManager::SetLoggedInUserImage(const SkBitmap& image) {
   if (logged_in_user_.email().empty())
     return;
   logged_in_user_.set_image(image);
   OnImageLoaded(logged_in_user_.email(), image);
 }
 
 void UserManager::SaveUserImage(const std::string& username,
                                 const SkBitmap& image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::string filename = username + ".png";
-  FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  FilePath image_path = user_data_dir.AppendASCII(filename);
+  FilePath image_path = GetImagePathForUser(username);
   DVLOG(1) << "Saving user image to " << image_path.value();
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       NewRunnableFunction(&SaveImageToFile,
                           image, image_path, username));
 }
 
 void UserManager::SetDefaultUserImage(const std::string& username) {
@@ skipping 57 matching lines @@
     : ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_(new UserImageLoader(this))),
       current_user_is_owner_(false) {
   registrar_.Add(this, NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
       NotificationService::AllSources());
 }
 
 UserManager::~UserManager() {
   image_loader_->set_delegate(NULL);
 }
 
+FilePath UserManager::GetImagePathForUser(const std::string& username) {
+  std::string filename = username + ".png";
+  FilePath user_data_dir;
+  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+  return user_data_dir.AppendASCII(filename);
+}
+
 void UserManager::NotifyOnLogin() {
   NotificationService::current()->Notify(
       NotificationType::LOGIN_USER_CHANGED,
       Source<UserManager>(this),
       Details<const User>(&logged_in_user_));
 
   chromeos::CrosLibrary::Get()->GetInputMethodLibrary()->
       SetDeferImeStartup(false);
   // Shut down the IME so that it will reload the user's settings.
   chromeos::CrosLibrary::Get()->GetInputMethodLibrary()->
@@ skipping 11 matching lines @@
 void UserManager::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (type == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableFunction(&CheckOwnership));
   }
 }
 
 }  // namespace chromeos