Revert 277655 "Remove more unretained"

trunk/src/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 333 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,
-                     weak_factory_.GetWeakPtr()));
+                     base::Unretained(this)));
 }
 
 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,
-                     weak_factory_.GetWeakPtr(),
+                     base::Unretained(this),
                      user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
                      base::Passed(MovableOnDestroyCallbackHolder())));
       return;
     }
     LoadWallpaper(user_id,
                   info,
                   false /* do not update wallpaper */,
@@ skipping 199 matching lines @@
       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,
-                   weak_factory_.GetWeakPtr(),
+                   base::Unretained(this),
                    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,
-                 weak_factory_.GetWeakPtr(),
+                 base::Unretained(this),
                  logged_in_user->email(),
                  logged_in_user->username_hash()));
 }
 
 void WallpaperManager::GetCustomWallpaperInternal(
     const std::string& user_id,
     const WallpaperInfo& info,
     const base::FilePath& wallpaper_path,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish) {
@@ skipping 15 matching lines @@
     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,
-                                       weak_factory_.GetWeakPtr(),
+                                       base::Unretained(this),
                                        user_id,
                                        base::Passed(on_finish.Pass())));
   } else {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&WallpaperManager::StartLoad,
-                                       weak_factory_.GetWeakPtr(),
+                                       base::Unretained(this),
                                        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.
@@ skipping 327 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