Use username_hash instead of email

chrome/browser/chromeos/login/wallpaper_manager.cc

 // Copyright (c) 2013 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/wallpaper_manager.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/command_line.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 
 namespace {
 
-const int kWallpaperUpdateIntervalSec = 24 * 60 * 60;
+// The amount of delay before starts to move custom wallpapers to the new place.
+const int kMoveCustomWallpaperDelaySeconds = 30;
 
 // Default quality for encoding wallpaper.
 const int kDefaultEncodingQuality = 90;
 
 // A dictionary pref that maps usernames to file paths to their wallpapers.
 // Deprecated. Will remove this const char after done migration.
 const char kUserWallpapers[] = "UserWallpapers";
 
 const int kThumbnailWidth = 128;
 const int kThumbnailHeight = 80;
@@ skipping 14 matching lines @@
 const char kOriginalCustomWallpaperSuffix[] = "_wallpaper";
 
 // Maximum number of wallpapers cached by CacheUsersWallpapers().
 const int kMaxWallpapersToCache = 3;
 
 // For our scaling ratios we need to round positive numbers.
 int RoundPositive(double x) {
   return static_cast<int>(floor(x + 0.5));
 }
 
-// Returns custom wallpaper directory by appending |sub_dir| and |email| as sub
-// directories.
-base::FilePath GetCustomWallpaperDir(const char* sub_dir,
-                                     const std::string& email) {
+// Returns custom wallpaper directory by appending corresponding |sub_dir|.
+base::FilePath GetCustomWallpaperDir(const char* sub_dir) {
   base::FilePath custom_wallpaper_dir;
   CHECK(PathService::Get(chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS,
                          &custom_wallpaper_dir));
-  return custom_wallpaper_dir.Append(sub_dir).Append(email);
+  return custom_wallpaper_dir.Append(sub_dir);
+}
+
+bool MoveCustomWallpaperDirectory(const char* sub_dir,
+                                  const std::string& email,
+                                  const std::string& user_id_hash) {
+  base::FilePath base_path = GetCustomWallpaperDir(sub_dir);
+  base::FilePath to_path = base_path.Append(user_id_hash);
+  base::FilePath from_path = base_path.Append(email);
+  if (base::PathExists(from_path))
+    return base::Move(from_path, to_path);
+  return false;
 }
 
 }  // namespace
 
 namespace chromeos {
 
 const char kWallpaperSequenceTokenName[] = "wallpaper-sequence";
 
 const char kSmallWallpaperSuffix[] = "_small";
 const char kLargeWallpaperSuffix[] = "_large";
@@ skipping 94 matching lines @@
 }
 
 void WallpaperManager::ClearWallpaperCache() {
   // Cancel callback for previous cache requests.
   weak_factory_.InvalidateWeakPtrs();
   wallpaper_cache_.clear();
 }
 
 base::FilePath WallpaperManager::GetCustomWallpaperPath(
     const char* sub_dir,
-    const std::string& email,
+    const std::string& user_id_hash,
     const std::string& file) {
-  base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir, email);
-  return custom_wallpaper_path.Append(file);
+  base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
+  return custom_wallpaper_path.Append(user_id_hash).Append(file);
 }
 
 bool WallpaperManager::GetWallpaperFromCache(const std::string& email,
                                              gfx::ImageSkia* wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(email);
   if (it != wallpaper_cache_.end()) {
     *wallpaper = (*it).second;
     return true;
   }
@@ skipping 56 matching lines @@
   SetUserWallpaper(user_manager->GetLoggedInUser()->email());
 }
 
 void WallpaperManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   switch (type) {
     case chrome::NOTIFICATION_LOGIN_USER_CHANGED: {
       ClearWallpaperCache();
+      MoveLoggedInUserCustomWallpaper();
       break;
     }
     case chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE: {
       if (!GetComandLine()->HasSwitch(switches::kDisableBootAnimation)) {
         BrowserThread::PostDelayedTask(
             BrowserThread::UI, FROM_HERE,
             base::Bind(&WallpaperManager::CacheUsersWallpapers,
                        weak_factory_.GetWeakPtr()),
             base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
       } else {
@@ skipping 11 matching lines @@
         should_cache_wallpaper_ = false;
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
 void WallpaperManager::RemoveUserWallpaperInfo(const std::string& email) {
+  WallpaperInfo info;
+  GetUserWallpaperInfo(email, &info);
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(email, NULL);
-
-  DeleteUserWallpapers(email);
+  DeleteUserWallpapers(email, info.file);
 }
 
 bool WallpaperManager::ResizeWallpaper(
     const UserImage& wallpaper,
     ash::WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
     scoped_refptr<base::RefCountedBytes>* output) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
@@ skipping 58 matching lines @@
   scoped_refptr<base::RefCountedBytes> data;
   if (ResizeWallpaper(wallpaper, layout, preferred_width, preferred_height,
                       &data)) {
     SaveWallpaperInternal(path,
                           reinterpret_cast<const char*>(data->front()),
                           data->size());
   }
 }
 
 void WallpaperManager::SetCustomWallpaper(const std::string& username,
+                                          const std::string& user_id_hash,
                                           const std::string& file,
                                           ash::WallpaperLayout layout,
                                           User::WallpaperType type,
                                           const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  base::FilePath wallpaper_path = GetCustomWallpaperPath(
-      kOriginalWallpaperSubDir,
-      username,
-      file);
+  base::FilePath wallpaper_path =
+      GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id_hash, file);
 
   // If decoded wallpaper is empty, we are probably failed to decode the file.
   // Use default wallpaper in this case.
   if (wallpaper.image().isNull()) {
     SetDefaultWallpaper();
     return;
   }
 
   bool is_persistent =
       !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(username);
@@ skipping 11 matching lines @@
   // Block shutdown on this task. Otherwise, we may lost the custom wallpaper
   // user selected.
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
               base::SequencedWorkerPool::BLOCK_SHUTDOWN);
   // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
   blocking_task_runner->PostTask(FROM_HERE,
       base::Bind(&WallpaperManager::ProcessCustomWallpaper,
                  base::Unretained(this),
-                 username,
+                 user_id_hash,
                  is_persistent,
                  wallpaper_info,
                  base::Passed(&deep_copy),
                  wallpaper.raw_image()));
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper.image(), layout);
 
-  // User's custom wallpaper path is determined by username/email and the
+  std::string relative_path = base::FilePath(user_id_hash).Append(file).value();
+  // User's custom wallpaper path is determined by relative path and the
   // appropriate wallpaper resolution in GetCustomWallpaperInternal.
   WallpaperInfo info = {
-      file,
+      relative_path,
       layout,
       User::CUSTOMIZED,
       base::Time::Now().LocalMidnight()
   };
   SetUserWallpaperInfo(username, info, is_persistent);
 }
 
 void WallpaperManager::SetDefaultWallpaper() {
   current_wallpaper_path_.clear();
   if (ash::Shell::GetInstance()->desktop_background_controller()->
@@ skipping 69 matching lines @@
       if (info.type == User::CUSTOMIZED) {
         ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
             desktop_background_controller()->GetAppropriateResolution();
         const char* sub_dir = (resolution == ash::WALLPAPER_RESOLUTION_SMALL) ?
             kSmallWallpaperSubDir : kLargeWallpaperSubDir;
         // Wallpaper is not resized when layout is ash::WALLPAPER_LAYOUT_CENTER.
         // Original wallpaper should be used in this case.
         // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
         if (info.layout == ash::WALLPAPER_LAYOUT_CENTER)
           sub_dir = kOriginalWallpaperSubDir;
-        base::FilePath wallpaper_path = GetCustomWallpaperPath(sub_dir, email,
-                                                               info.file);
+        base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
+        wallpaper_path = wallpaper_path.Append(info.file);
         if (current_wallpaper_path_ == wallpaper_path)
           return;
         current_wallpaper_path_ = wallpaper_path;
         loaded_wallpapers_++;
 
         task_runner_->PostTask(FROM_HERE,
             base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                        base::Unretained(this), email, info, wallpaper_path,
                        true /* update wallpaper */));
         return;
@@ skipping 59 matching lines @@
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(email, &info)) {
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
     if (info.type == User::CUSTOMIZED) {
       ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
           desktop_background_controller()->GetAppropriateResolution();
       const char* sub_dir  = (resolution == ash::WALLPAPER_RESOLUTION_SMALL) ?
             kSmallWallpaperSubDir : kLargeWallpaperSubDir;
-      base::FilePath wallpaper_path = GetCustomWallpaperPath(sub_dir, email,
-                                                             info.file);
+      base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
+      wallpaper_path = wallpaper_path.Append(info.file);
       task_runner_->PostTask(FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      base::Unretained(this), email, info, wallpaper_path,
                      false /* do not update wallpaper */));
       return;
     }
     LoadWallpaper(email, info, false /* do not update wallpaper */);
   }
 }
 
@@ skipping 25 matching lines @@
     base::FilePath path = *it;
     // Some users may still have legacy wallpapers with png extension. We need
     // to delete these wallpapers too.
     if (!base::DeleteFile(path, true) &&
         !base::DeleteFile(path.AddExtension(".png"), false)) {
       LOG(ERROR) << "Failed to remove user wallpaper at " << path.value();
     }
   }
 }
 
-void WallpaperManager::DeleteUserWallpapers(const std::string& email) {
+void WallpaperManager::DeleteUserWallpapers(const std::string& email,
+                                            const std::string& path_to_file) {
   std::vector<base::FilePath> file_to_remove;
   // Remove small user wallpaper.
   base::FilePath wallpaper_path =
-      GetCustomWallpaperDir(kSmallWallpaperSubDir, email);
+      GetCustomWallpaperDir(kSmallWallpaperSubDir);
+  // Remove old directory if exists
+  file_to_remove.push_back(wallpaper_path.Append(email));
+  wallpaper_path = wallpaper_path.Append(path_to_file).DirName();
   file_to_remove.push_back(wallpaper_path);
 
   // Remove large user wallpaper.
-  wallpaper_path = GetCustomWallpaperDir(kLargeWallpaperSubDir, email);
+  wallpaper_path = GetCustomWallpaperDir(kLargeWallpaperSubDir);
+  file_to_remove.push_back(wallpaper_path.Append(email));
+  wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   // Remove user wallpaper thumbnail.
-  wallpaper_path = GetCustomWallpaperDir(kThumbnailWallpaperSubDir, email);
+  wallpaper_path = GetCustomWallpaperDir(kThumbnailWallpaperSubDir);
+  file_to_remove.push_back(wallpaper_path.Append(email));
+  wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   // Remove original user wallpaper.
-  wallpaper_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir, email);
+  wallpaper_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
+  file_to_remove.push_back(wallpaper_path.Append(email));
+  wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::DeleteWallpaperInList,
                  base::Unretained(this),
                  file_to_remove),
       false);
 }
 
 void WallpaperManager::EnsureCustomWallpaperDirectories(
-    const std::string& email) {
+    const std::string& user_id_hash) {
   base::FilePath dir;
-  dir = GetCustomWallpaperDir(kSmallWallpaperSubDir, email);
+  dir = GetCustomWallpaperDir(kSmallWallpaperSubDir);
+  dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     file_util::CreateDirectory(dir);
-  dir = GetCustomWallpaperDir(kLargeWallpaperSubDir, email);
+  dir = GetCustomWallpaperDir(kLargeWallpaperSubDir);
+  dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     file_util::CreateDirectory(dir);
-  dir = GetCustomWallpaperDir(kOriginalWallpaperSubDir, email);
+  dir = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
+  dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     file_util::CreateDirectory(dir);
-  dir = GetCustomWallpaperDir(kThumbnailWallpaperSubDir, email);
+  dir = GetCustomWallpaperDir(kThumbnailWallpaperSubDir);
+  dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     file_util::CreateDirectory(dir);
 }
 
 CommandLine* WallpaperManager::GetComandLine() {
   CommandLine* command_line = command_line_for_testing_ ?
       command_line_for_testing_ : CommandLine::ForCurrentProcess();
   return command_line;
 }
 
@@ skipping 98 matching lines @@
                                          &date_string) &&
           base::StringToInt64(date_string, &val)))
       val = 0;
     info->date = base::Time::FromInternalValue(val);
     return true;
   }
 
   return false;
 }
 
+void WallpaperManager::MoveCustomWallpapersOnWorker(
+    const std::string& email,
+    const std::string& user_id_hash) {
+  DCHECK(BrowserThread::GetBlockingPool()->
+      IsRunningSequenceOnCurrentThread(sequence_token_));
+  if (MoveCustomWallpaperDirectory(kOriginalWallpaperSubDir,
+                                   email,
+                                   user_id_hash)) {
+    // Consider success if the original wallpaper is moved to the new directory.
+    // Original wallpaper is the fallback if the correct resolution wallpaper
+    // can not be found.
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&WallpaperManager::MoveCustomWallpapersSuccess,
+                   base::Unretained(this),
+                   email,
+                   user_id_hash));
+  }
+  MoveCustomWallpaperDirectory(kLargeWallpaperSubDir, email, user_id_hash);
+  MoveCustomWallpaperDirectory(kSmallWallpaperSubDir, email, user_id_hash);
+  MoveCustomWallpaperDirectory(kThumbnailWallpaperSubDir, email, user_id_hash);
+}
+
+void WallpaperManager::MoveCustomWallpapersSuccess(
+    const std::string& email,
+    const std::string& user_id_hash) {
+  WallpaperInfo info;
+  GetUserWallpaperInfo(email, &info);
+  if (info.type == User::CUSTOMIZED) {
+    // New file field should include user id hash in addition to file name.
+    // This is needed because at login screen, user id hash is not available.
+    std::string relative_path =
+        base::FilePath(user_id_hash).Append(info.file).value();
+    info.file = relative_path;
+    bool is_persistent =
+        !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(email);
+    SetUserWallpaperInfo(email, info, is_persistent);
+  }
+}
+
+void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
+  const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
+  task_runner_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&WallpaperManager::MoveCustomWallpapersOnWorker,
+                 weak_factory_.GetWeakPtr(),
+                 logged_in_user->email(),
+                 logged_in_user->username_hash()),
+      base::TimeDelta::FromSeconds(kMoveCustomWallpaperDelaySeconds));
+}
+
 void WallpaperManager::GetCustomWallpaperInternal(
     const std::string& email,
     const WallpaperInfo& info,
     const base::FilePath& wallpaper_path,
     bool update_wallpaper) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
 
   base::FilePath valid_path = wallpaper_path;
   if (!base::PathExists(wallpaper_path)) {
     // Falls back on original file if the correct resoltuion file does not
     // exist. This may happen when the original custom wallpaper is small or
     // browser shutdown before resized wallpaper saved.
+    valid_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
+    valid_path = valid_path.Append(info.file);
+  }
+
+  if (!base::PathExists(valid_path)) {
+    // Falls back to custom wallpaper that uses email as part of its file path.
+    // Note that email is used instead of user_id_hash here.
     valid_path = GetCustomWallpaperPath(kOriginalWallpaperSubDir, email,
                                         info.file);
   }
 
   if (!base::PathExists(valid_path)) {
     LOG(ERROR) << "Failed to load previously selected custom wallpaper. " <<
                   "Fallback to default wallpaper";
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::SetDefaultWallpaper,
@@ skipping 38 matching lines @@
   if (!UserManager::Get()->IsUserLoggedIn()) {
     wallpaper_cache_.insert(std::make_pair(email, wallpaper.image()));
   }
   if (update_wallpaper) {
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetCustomWallpaper(wallpaper.image(), layout);
   }
 }
 
 void WallpaperManager::ProcessCustomWallpaper(
-    const std::string& email,
+    const std::string& user_id_hash,
     bool persistent,
     const WallpaperInfo& info,
     scoped_ptr<gfx::ImageSkia> image,
     const UserImage::RawImage& raw_image) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
   UserImage wallpaper(*image.get(), raw_image);
   if (persistent) {
-    SaveCustomWallpaper(email, base::FilePath(info.file), info.layout,
+    SaveCustomWallpaper(user_id_hash, base::FilePath(info.file), info.layout,
                         wallpaper);
   }
 }
 
-void WallpaperManager::SaveCustomWallpaper(const std::string& email,
+void WallpaperManager::SaveCustomWallpaper(const std::string& user_id_hash,
                                            const base::FilePath& original_path,
                                            ash::WallpaperLayout layout,
                                            const UserImage& wallpaper) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
-  EnsureCustomWallpaperDirectories(email);
+  EnsureCustomWallpaperDirectories(user_id_hash);
   std::string file_name = original_path.BaseName().value();
   base::FilePath small_wallpaper_path =
-      GetCustomWallpaperPath(kSmallWallpaperSubDir, email, file_name);
+      GetCustomWallpaperPath(kSmallWallpaperSubDir, user_id_hash, file_name);
   base::FilePath large_wallpaper_path =
-      GetCustomWallpaperPath(kLargeWallpaperSubDir, email, file_name);
+      GetCustomWallpaperPath(kLargeWallpaperSubDir, user_id_hash, file_name);
 
   // Re-encode orginal file to jpeg format and saves the result in case that
   // resized wallpaper is not generated (i.e. chrome shutdown before resized
   // wallpaper is saved).
   ResizeAndSaveWallpaper(wallpaper, original_path,
                          ash::WALLPAPER_LAYOUT_STRETCH,
                          wallpaper.image().width(),
                          wallpaper.image().height());
   DeleteAllExcept(original_path);
 
@@ skipping 30 matching lines @@
   // |sequence_token_| here.
   wallpaper_loader_->Start(wallpaper_path.value(), 0, sequence_token_,
                            base::Bind(&WallpaperManager::OnWallpaperDecoded,
                                       base::Unretained(this),
                                       email,
                                       info.layout,
                                       update_wallpaper));
 }
 
 }  // namespace chromeos