Remove more unretained

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 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/users/wallpaper/wallpaper_manager.h"
 
 #include <numeric>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 155 matching lines @@
     // 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();
     }
   }
 }
 
 // Creates all new custom wallpaper directories for |user_id_hash| if not exist.
+// static
 void EnsureCustomWallpaperDirectories(const std::string& user_id_hash) {
   base::FilePath dir;
   dir = GetCustomWallpaperDir(kSmallWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
   dir = GetCustomWallpaperDir(kLargeWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
@@ skipping 204 matching lines @@
   if (default_) {
     manager->DoSetDefaultWallpaper(user_id_, on_finish_.Pass());
   } else if (!user_wallpaper_.isNull()) {
     ash::Shell::GetInstance()
         ->desktop_background_controller()
         ->SetWallpaperImage(user_wallpaper_, info_.layout);
   } else if (!wallpaper_path_.empty()) {
     manager->task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
-                   base::Unretained(manager),
                    user_id_,
                    info_,
                    wallpaper_path_,
                    true /* update wallpaper */,
-                   base::Passed(on_finish_.Pass())));
+                   base::Passed(on_finish_.Pass()),
+                   manager->weak_factory_.GetWeakPtr()));
   } else if (!info_.file.empty()) {
     manager->LoadWallpaper(user_id_, info_, true, on_finish_.Pass());
   } else {
     // PendingWallpaper was created and never initialized?
     NOTREACHED();
     // Error. Do not record time.
     started_load_at_ = base::Time();
   }
   on_finish_.reset();
 }
@@ skipping 103 matching lines @@
   registry->RegisterDictionaryPref(prefs::kUsersWallpaperInfo);
   registry->RegisterDictionaryPref(kUserWallpapers);
   registry->RegisterDictionaryPref(kUserWallpapersProperties);
 }
 
 void WallpaperManager::AddObservers() {
   show_user_name_on_signin_subscription_ =
       CrosSettings::Get()->AddSettingsObserver(
           kAccountsPrefShowUserNamesOnSignIn,
           base::Bind(&WallpaperManager::InitializeRegisteredDeviceWallpaper,
-                     base::Unretained(this)));
+                     weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::EnsureLoggedInUserWallpaperLoaded() {
   // Some browser tests do not have a shell instance. As no wallpaper is needed
   // in these tests anyway, avoid loading one, preventing crashes and speeding
   // up the tests.
   if (!ash::Shell::HasInstance())
     return;
 
   WallpaperInfo info;
@@ skipping 22 matching lines @@
   for (CustomWallpaperMap::iterator it = wallpaper_cache_.begin();
        it != wallpaper_cache_.end(); ++it) {
     if (logged_in_users_names.find(it->first) !=
         logged_in_users_names.end()) {
       logged_in_users_cache.insert(*it);
     }
   }
   wallpaper_cache_ = logged_in_users_cache;
 }
 
-base::FilePath WallpaperManager::GetCustomWallpaperPath(
-    const char* sub_dir,
-    const std::string& user_id_hash,
-    const std::string& file) const {
-  base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
-  return custom_wallpaper_path.Append(user_id_hash).Append(file);
-}
-
 bool WallpaperManager::GetLoggedInUserWallpaperInfo(WallpaperInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (UserManager::Get()->IsLoggedInAsStub()) {
     info->file = current_user_wallpaper_info_.file = "";
     info->layout = current_user_wallpaper_info_.layout =
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type = User::DEFAULT;
     info->date = current_user_wallpaper_info_.date =
         base::Time::Now().LocalMidnight();
@@ skipping 231 matching lines @@
 WallpaperManager::GetAppropriateResolution() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   gfx::Size size =
       ash::DesktopBackgroundController::GetMaxDisplaySizeInNative();
   return (size.width() > kSmallWallpaperMaxWidth ||
           size.height() > kSmallWallpaperMaxHeight)
              ? WALLPAPER_RESOLUTION_LARGE
              : WALLPAPER_RESOLUTION_SMALL;
 }
 
+// static
+base::FilePath WallpaperManager::GetCustomWallpaperPath(
+    const char* sub_dir,
+    const std::string& user_id_hash,
+    const std::string& file) {
+  base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
+  return custom_wallpaper_path.Append(user_id_hash).Append(file);
+}
+
+// static
+void WallpaperManager::RecordUma(User::WallpaperType type, int index) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "Ash.Wallpaper.Type", type, User::WALLPAPER_TYPE_COUNT);
+}
+
+// static
+void WallpaperManager::SaveCustomWallpaper(const std::string& user_id_hash,
+                                           const base::FilePath& original_path,
+                                           ash::WallpaperLayout layout,
+                                           scoped_ptr<gfx::ImageSkia> image) {
+  EnsureCustomWallpaperDirectories(user_id_hash);
+  std::string file_name = original_path.BaseName().value();
+  base::FilePath small_wallpaper_path =
+      GetCustomWallpaperPath(kSmallWallpaperSubDir, user_id_hash, file_name);
+  base::FilePath large_wallpaper_path =
+      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(*image,
+                         original_path,
+                         ash::WALLPAPER_LAYOUT_STRETCH,
+                         image->width(),
+                         image->height(),
+                         NULL);
+  DeleteAllExcept(original_path);
+
+  ResizeAndSaveWallpaper(*image,
+                         small_wallpaper_path,
+                         layout,
+                         kSmallWallpaperMaxWidth,
+                         kSmallWallpaperMaxHeight,
+                         NULL);
+  DeleteAllExcept(small_wallpaper_path);
+  ResizeAndSaveWallpaper(*image,
+                         large_wallpaper_path,
+                         layout,
+                         kLargeWallpaperMaxWidth,
+                         kLargeWallpaperMaxHeight,
+                         NULL);
+  DeleteAllExcept(large_wallpaper_path);
+}
+
 void WallpaperManager::SetPolicyControlledWallpaper(
     const std::string& user_id,
     const UserImage& user_image) {
   const User *user = chromeos::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
   SetCustomWallpaper(user_id,
                      user->username_hash(),
@@ skipping 48 matching lines @@
     // Block shutdown on this task. Otherwise, we may lose the custom wallpaper
     // that the 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::SaveCustomWallpaper,
-                   base::Unretained(this),
                    user_id_hash,
                    base::FilePath(wallpaper_info.file),
                    wallpaper_info.layout,
                    base::Passed(deep_copy.Pass())));
   }
 
   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 = {
@@ skipping 264 matching lines @@
 
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
     if (info.type == User::CUSTOMIZED || info.type == User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       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),
                      user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
-                     base::Passed(MovableOnDestroyCallbackHolder())));
+                     base::Passed(MovableOnDestroyCallbackHolder()),
+                     weak_factory_.GetWeakPtr()));
       return;
     }
     LoadWallpaper(user_id,
                   info,
                   false /* do not update wallpaper */,
                   MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 void WallpaperManager::ClearObsoleteWallpaperPrefs() {
@@ skipping 182 matching lines @@
 
   info->file = file;
   info->layout = static_cast<ash::WallpaperLayout>(layout);
   info->type = static_cast<User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
 void WallpaperManager::MoveCustomWallpapersOnWorker(
     const std::string& user_id,
-    const std::string& user_id_hash) {
+    const std::string& user_id_hash,
+    base::WeakPtr<WallpaperManager> weak_ptr) {
+  /*
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
+  */
   if (MoveCustomWallpaperDirectory(
           kOriginalWallpaperSubDir, user_id, 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),
+                   weak_ptr,
                    user_id,
                    user_id_hash));
   }
   MoveCustomWallpaperDirectory(kLargeWallpaperSubDir, user_id, user_id_hash);
   MoveCustomWallpaperDirectory(kSmallWallpaperSubDir, user_id, user_id_hash);
   MoveCustomWallpaperDirectory(
       kThumbnailWallpaperSubDir, user_id, user_id_hash);
 }
 
 void WallpaperManager::MoveCustomWallpapersSuccess(
@@ skipping 11 matching lines @@
         !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
   const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::MoveCustomWallpapersOnWorker,
-                 base::Unretained(this),
                  logged_in_user->email(),
-                 logged_in_user->username_hash()));
+                 logged_in_user->username_hash(),
+                 weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::GetCustomWallpaperInternal(
     const std::string& user_id,
     const WallpaperInfo& info,
     const base::FilePath& wallpaper_path,
     bool update_wallpaper,
-    MovableOnDestroyCallbackHolder on_finish) {
+    MovableOnDestroyCallbackHolder on_finish,
+    base::WeakPtr<WallpaperManager> weak_ptr) {
+  /*
   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 resolution 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, user_id, 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::DoSetDefaultWallpaper,
-                                       base::Unretained(this),
+                                       weak_ptr,
                                        user_id,
                                        base::Passed(on_finish.Pass())));
   } else {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::StartLoad,
-                                       base::Unretained(this),
+                                       weak_ptr,
                                        user_id,
                                        info,
                                        update_wallpaper,
                                        valid_path,
                                        base::Passed(on_finish.Pass())));
   }
 }
 
 void WallpaperManager::OnWallpaperDecoded(
     const std::string& user_id,
@@ skipping 23 matching lines @@
 
   wallpaper_cache_[user_id] = user_image.image();
 
   if (update_wallpaper) {
     ash::Shell::GetInstance()
         ->desktop_background_controller()
         ->SetWallpaperImage(user_image.image(), layout);
   }
 }
 
-void WallpaperManager::SaveCustomWallpaper(
-    const std::string& user_id_hash,
-    const base::FilePath& original_path,
-    ash::WallpaperLayout layout,
-    scoped_ptr<gfx::ImageSkia> image) const {
-  DCHECK(BrowserThread::GetBlockingPool()->
-      IsRunningSequenceOnCurrentThread(sequence_token_));
-  EnsureCustomWallpaperDirectories(user_id_hash);
-  std::string file_name = original_path.BaseName().value();
-  base::FilePath small_wallpaper_path =
-      GetCustomWallpaperPath(kSmallWallpaperSubDir, user_id_hash, file_name);
-  base::FilePath large_wallpaper_path =
-      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(*image,
-                         original_path,
-                         ash::WALLPAPER_LAYOUT_STRETCH,
-                         image->width(),
-                         image->height(),
-                         NULL);
-  DeleteAllExcept(original_path);
-
-  ResizeAndSaveWallpaper(*image,
-                         small_wallpaper_path,
-                         layout,
-                         kSmallWallpaperMaxWidth,
-                         kSmallWallpaperMaxHeight,
-                         NULL);
-  DeleteAllExcept(small_wallpaper_path);
-  ResizeAndSaveWallpaper(*image,
-                         large_wallpaper_path,
-                         layout,
-                         kLargeWallpaperMaxWidth,
-                         kLargeWallpaperMaxHeight,
-                         NULL);
-  DeleteAllExcept(large_wallpaper_path);
-}
-
-void WallpaperManager::RecordUma(User::WallpaperType type, int index) const {
-  UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", type,
-                            User::WALLPAPER_TYPE_COUNT);
-}
-
 void WallpaperManager::StartLoad(const std::string& user_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
 
   wallpaper_loader_->Start(wallpaper_path.value(),
                            0,  // Do not crop.
                            base::Bind(&WallpaperManager::OnWallpaperDecoded,
-                                      base::Unretained(this),
+                                      weak_factory_.GetWeakPtr(),
                                       user_id,
                                       info.layout,
                                       update_wallpaper,
                                       base::Passed(on_finish.Pass())));
 }
 
 void WallpaperManager::SaveLastLoadTime(const base::TimeDelta elapsed) {
   while (last_load_times_.size() >= kLastLoadsStatsMsMaxSize)
     last_load_times_.pop_front();
 
@@ skipping 75 matching lines @@
   wallpaper.image().EnsureRepsForSupportedScales();
   scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.image().DeepCopy());
 
   scoped_ptr<bool> success(new bool(false));
   scoped_ptr<gfx::ImageSkia> small_wallpaper_image(new gfx::ImageSkia);
   scoped_ptr<gfx::ImageSkia> large_wallpaper_image(new gfx::ImageSkia);
 
   // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
   base::Closure resize_closure =
       base::Bind(&WallpaperManager::ResizeCustomizedDefaultWallpaper,
-                 base::Unretained(this),
                  base::Passed(&deep_copy),
                  wallpaper.raw_image(),
                  base::Unretained(rescaled_files.get()),
                  base::Unretained(success.get()),
                  base::Unretained(small_wallpaper_image.get()),
                  base::Unretained(large_wallpaper_image.get()));
   base::Closure on_resized_closure =
       base::Bind(&WallpaperManager::OnCustomizedDefaultWallpaperResized,
                  weak_factory_.GetWeakPtr(),
                  wallpaper_url,
                  base::Passed(rescaled_files.Pass()),
                  base::Passed(success.Pass()),
                  base::Passed(small_wallpaper_image.Pass()),
                  base::Passed(large_wallpaper_image.Pass()));
 
   if (!task_runner_->PostTaskAndReply(
           FROM_HERE, resize_closure, on_resized_closure)) {
     LOG(WARNING) << "Failed to start Customized Wallpaper resize.";
   }
 }
 
 void WallpaperManager::ResizeCustomizedDefaultWallpaper(
     scoped_ptr<gfx::ImageSkia> image,
     const UserImage::RawImage& raw_image,
     const CustomizedWallpaperRescaledFiles* rescaled_files,
     bool* success,
     gfx::ImageSkia* small_wallpaper_image,
     gfx::ImageSkia* large_wallpaper_image) {
-  DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
-      sequence_token_));
-
   *success = true;
 
   *success &= ResizeAndSaveWallpaper(*image,
                                      rescaled_files->path_rescaled_small(),
                                      ash::WALLPAPER_LAYOUT_STRETCH,
                                      kSmallWallpaperMaxWidth,
                                      kSmallWallpaperMaxHeight,
                                      small_wallpaper_image);
 
   *success &= ResizeAndSaveWallpaper(*image,
@@ skipping 188 matching lines @@
   loaded_wallpapers_++;
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1, 1, 0);
   bitmap.allocPixels();
   bitmap.eraseColor(kDefaultWallpaperColor);
   const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
   default_wallpaper_image_.reset(new UserImage(image));
 }
 
 }  // namespace chromeos