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,
+std::string WallpaperManager::ResizeWallpaper(const UserImage& wallpaper,
                                               ash::WallpaperLayout layout,
                                               int preferred_width,
                                               int preferred_height) {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
   int width = wallpaper.image().width();
   int height = wallpaper.image().height();
   int resized_width;
   int resized_height;
 
   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 std::string();
 
     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());
+  return std::string(reinterpret_cast<const char*>(data->front()),

[Nikita (slow), 2013/03/06 16:51:17]

Is this the only way to return resized Wallpaper?
I would expect this to be an output parameter with array of char* and
ResizeWallpaper returning bool.

[flackr, 2013/03/06 18:22:24]

But we don't know in advance the size of the resized image. I could see an
output vector.

[bshe, 2013/03/07 05:34:35]

I changed the signature according to nikita's suggestion. Also, I use ref
counted bytes in the hope of reduce unnecessary copy.

On 2013/03/06 18:22:24, flackr wrote:

+                     data->size());
+}
+
+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;
+  }
+  std::string resized_wallpaper_string =
+      ResizeWallpaper(wallpaper, layout, preferred_width, preferred_height);
+  if (!resized_wallpaper_string.empty()) {
+    SaveWallpaperInternal(path,
+                          resized_wallpaper_string.c_str(),
+                          resized_wallpaper_string.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