New custom wallpaper picker UI

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 310 matching lines @@
 
 void WallpaperManager::RemoveUserWallpaperInfo(const std::string& email) {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(email, NULL);
 
   DeleteUserWallpapers(email);
 }
 
-void WallpaperManager::ResizeAndSaveWallpaper(const UserImage& wallpaper,
-                                              const base::FilePath& path,
-                                              ash::WallpaperLayout layout,
-                                              int preferred_width,
-                                              int preferred_height) {
+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_));
   int width = wallpaper.image().width();
   int height = wallpaper.image().height();
   int resized_width;
   int resized_height;
+  *output = new base::RefCountedBytes();
 
   if (layout == ash::WALLPAPER_LAYOUT_CENTER_CROPPED) {
     // Do not resize custom wallpaper if it is smaller than preferred size.
     if (!(width > preferred_width && height > preferred_height))
-      return;
+      return false;
 
     double horizontal_ratio = static_cast<double>(preferred_width) / width;
     double vertical_ratio = static_cast<double>(preferred_height) / height;
     if (vertical_ratio > horizontal_ratio) {
       resized_width =
           RoundPositive(static_cast<double>(width) * vertical_ratio);
       resized_height = preferred_height;
     } else {
       resized_width = preferred_width;
       resized_height =
           RoundPositive(static_cast<double>(height) * horizontal_ratio);
     }
   } else if (layout == ash::WALLPAPER_LAYOUT_STRETCH) {
     resized_width = preferred_width;
     resized_height = preferred_height;
   } else {
-    // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
-    if (file_util::PathExists(path))
-      file_util::Delete(path, false);
-    return;
+    resized_width = width;
+    resized_height = height;
   }
 
   gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
       wallpaper.image(),
       skia::ImageOperations::RESIZE_LANCZOS3,
       gfx::Size(resized_width, resized_height));
 
   SkBitmap image = *(resized_image.bitmap());
-  scoped_refptr<base::RefCountedBytes> data = new base::RefCountedBytes();
   SkAutoLockPixels lock_input(image);
   gfx::JPEGCodec::Encode(
       reinterpret_cast<unsigned char*>(image.getAddr32(0, 0)),
       gfx::JPEGCodec::FORMAT_SkBitmap,
       image.width(),
       image.height(),
       image.width() * image.bytesPerPixel(),
-      kDefaultEncodingQuality, &data->data());
-  SaveWallpaperInternal(path,
-                        reinterpret_cast<const char*>(data->front()),
-                        data->size());
+      kDefaultEncodingQuality, &(*output)->data());
+  return true;
+}
+
+void WallpaperManager::ResizeAndSaveWallpaper(const UserImage& wallpaper,
+                                              const base::FilePath& path,
+                                              ash::WallpaperLayout layout,
+                                              int preferred_width,
+                                              int preferred_height) {
+  if (layout == ash::WALLPAPER_LAYOUT_CENTER) {
+    // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
+    if (file_util::PathExists(path))
+      file_util::Delete(path, false);
+    return;
+  }
+  scoped_refptr<base::RefCountedBytes> data;
+  if (ResizeWallpaper(wallpaper, layout, preferred_width, preferred_height,
+                      &data)) {

[flackr, 2013/03/07 14:46:47]

If the image is smaller than the preferred width and height will the code know
to use the original image even though this doesn't return anything?

[bshe, 2013/03/07 16:13:05]

If it is smaller than preferred size, we wont try to resize and save that
wallpaper. And we will automatically fallback to use the original wallpaper if
we can't find wallpaper at requested resolution.

On 2013/03/07 14:46:47, flackr wrote:

+    SaveWallpaperInternal(path,
+                          reinterpret_cast<const char*>(data->front()),
+                          data->size());
+  }
 }
 
 void WallpaperManager::RestartTimer() {
   timer_.Stop();
   // Determine the next update time as the earliest local midnight after now.
   // Note that this may be more than kWallpaperUpdateIntervalSec seconds in the
   // future due to DST.
   base::Time now = base::Time::Now();
   base::TimeDelta update_interval = base::TimeDelta::FromSeconds(
       kWallpaperUpdateIntervalSec);
@@ skipping 157 matching lines @@
     gfx::ImageSkia user_wallpaper;
     if (GetWallpaperFromCache(email, &user_wallpaper)) {
       ash::Shell::GetInstance()->desktop_background_controller()->
           SetCustomWallpaper(user_wallpaper, info.layout);
     } else {
       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);
         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,
@@ skipping 78 matching lines @@
 
 void WallpaperManager::ClearObsoleteWallpaperPrefs() {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate wallpaper_properties_pref(prefs,
       kUserWallpapersProperties);
   wallpaper_properties_pref->Clear();
   DictionaryPrefUpdate wallpapers_pref(prefs, kUserWallpapers);
   wallpapers_pref->Clear();
 }
 
+void WallpaperManager::DeleteAllExcept(const base::FilePath& path) {
+  base::FilePath dir = path.DirName();
+  if (file_util::DirectoryExists(dir)) {
+    file_util::FileEnumerator files(dir, false,
+                                    file_util::FileEnumerator::FILES);
+    for (base::FilePath current = files.Next(); !current.empty();
+         current = files.Next()) {
+      if (current != path)
+        file_util::Delete(current, false);
+    }
+  }
+}
+
 void WallpaperManager::DeleteWallpaperInList(
     const std::vector<base::FilePath>& file_list) {
   for (std::vector<base::FilePath>::const_iterator it = file_list.begin();
        it != file_list.end(); ++it) {
     base::FilePath path = *it;
     // Some users may still have legacy wallpapers with png extension. We need
     // to delete these wallpapers too.
     if (!file_util::Delete(path, true) &&
         !file_util::Delete(path.AddExtension(".png"), false)) {
       LOG(ERROR) << "Failed to remove user wallpaper at " << path.value();
@@ skipping 351 matching lines @@
       GetCustomWallpaperPath(kSmallWallpaperSubDir, email, file_name);
   base::FilePath large_wallpaper_path =
       GetCustomWallpaperPath(kLargeWallpaperSubDir, email, file_name);
 
   std::vector<unsigned char> image_data = wallpaper.raw_image();
   // Saves the original file in case that resized wallpaper is not generated
   // (i.e. chrome shutdown before resized wallpaper is saved).
   SaveWallpaperInternal(original_path,
                         reinterpret_cast<char*>(&*image_data.begin()),
                         image_data.size());
+  DeleteAllExcept(original_path);
 
   ResizeAndSaveWallpaper(wallpaper, small_wallpaper_path, layout,
                          ash::kSmallWallpaperMaxWidth,
                          ash::kSmallWallpaperMaxHeight);
+  DeleteAllExcept(small_wallpaper_path);
   ResizeAndSaveWallpaper(wallpaper, large_wallpaper_path, layout,
                          ash::kLargeWallpaperMaxWidth,
                          ash::kLargeWallpaperMaxHeight);
+  DeleteAllExcept(large_wallpaper_path);
 }
 
 void WallpaperManager::RecordUma(User::WallpaperType type, int index) {
   UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", type,
                             User::WALLPAPER_TYPE_COUNT);
 }
 
 void WallpaperManager::SaveWallpaperInternal(const base::FilePath& path,
                                              const char* data,
                                              int size) {
@@ skipping 19 matching lines @@
 
 void WallpaperManager::SystemResumed(const base::TimeDelta& sleep_duration) {
   BatchUpdateWallpaper();
 }
 
 void WallpaperManager::TimezoneChanged(const icu::TimeZone& timezone) {
   RestartTimer();
 }
 
 }  // chromeos