Use weak pointer to where possible

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);
+}
+
 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 62 matching lines @@
   }
   // 1x1 wallpaper is actually solid color, so it should be stretched.
   if (default_wallpaper_image_->image().width() == 1 &&
       default_wallpaper_image_->image().height() == 1)
     layout = ash::WALLPAPER_LAYOUT_STRETCH;
 
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
       default_wallpaper_image_->image(), layout);
 }
 
+// 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);
+}
+
+// static
+void WallpaperManager::MoveCustomWallpapersOnWorker(
+    const std::string& user_id,
+    const std::string& user_id_hash,
+    base::WeakPtr<WallpaperManager> weak_ptr) {
+
+  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_ptr,

[Alexander Alekseev, 2014/06/18 19:11:18]

This seems to be dangerous, as WeakPtr is not thread-safe.

|weak_ptr| was created on UI thread, and will be destroyed on UI thread.

We are on Worker Pool now. So, a new WeakPtr is created here, and it will be
owned (and destroyed) by current thread.

Correct, but ugly idea: WallpaperManager could actually be:

class WallpaperManager {
 public:
  ~WallpaperManager() {
    impl.destroy(); // Mark internal state "destroyed"
  }
 private:
  scoped_ptr<WallpaperManagerImpl> impl;
};

And then WallpaperManagerImpl might actually be RefCountedThreadSafe.
But we'll have to check "destroyed" state in all cross-threads methods...

[oshima, 2014/06/18 19:25:25]

It's safe to pass WeakPtr between threads. The dereferencing has to be done on
the same thread it was craeted. See the document in base/memory/weak_ptr.h.

[Alexander Alekseev, 2014/06/18 19:57:58]

Yes, you're right.

+                   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);
+}
+
+// static
+void WallpaperManager::GetCustomWallpaperInternal(
+    const std::string& user_id,
+    const WallpaperInfo& info,
+    const base::FilePath& wallpaper_path,
+    bool update_wallpaper,
+    MovableOnDestroyCallbackHolder on_finish,
+    base::WeakPtr<WallpaperManager> weak_ptr) {
+
+  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,
+                                       weak_ptr,
+                                       user_id,
+                                       base::Passed(on_finish.Pass())));
+  } else {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&WallpaperManager::StartLoad,
+                                       weak_ptr,
+                                       user_id,
+                                       info,
+                                       update_wallpaper,
+                                       valid_path,
+                                       base::Passed(on_finish.Pass())));
+  }
+}
+
 void WallpaperManager::InitInitialUserWallpaper(const std::string& user_id,
                                                 bool is_persistent) {
   current_user_wallpaper_info_.file = "";
   current_user_wallpaper_info_.layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
   current_user_wallpaper_info_.type = User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
   SetUserWallpaperInfo(user_id, info, is_persistent);
 }
@@ skipping 182 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 180 matching lines @@
   if (!base::StringToInt64(date_string, &date_val))
     return false;
 
   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) {
-  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),
-                   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(
     const std::string& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &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(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()));
-}
-
-void WallpaperManager::GetCustomWallpaperInternal(
-    const std::string& user_id,
-    const WallpaperInfo& info,
-    const base::FilePath& wallpaper_path,
-    bool update_wallpaper,
-    MovableOnDestroyCallbackHolder on_finish) {
-  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),
-                                       user_id,
-                                       base::Passed(on_finish.Pass())));
-  } else {
-    BrowserThread::PostTask(BrowserThread::UI,
-                            FROM_HERE,
-                            base::Bind(&WallpaperManager::StartLoad,
-                                       base::Unretained(this),
-                                       user_id,
-                                       info,
-                                       update_wallpaper,
-                                       valid_path,
-                                       base::Passed(on_finish.Pass())));
-  }
+                 logged_in_user->username_hash(),
+                 weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::OnWallpaperDecoded(
     const std::string& user_id,
     ash::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     const UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
@@ skipping 17 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