Resize and save custom wallpaper to large and small size

chrome/browser/chromeos/login/wallpaper_manager.cc

 // Copyright (c) 2012 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 "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_resources.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/login/simple_png_encoder.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ skipping 58 matching lines @@
 gfx::ImageSkia ImageSkiaDeepCopy(const gfx::ImageSkia& image) {
   gfx::ImageSkia copy;
   std::vector<gfx::ImageSkiaRep> reps = image.image_reps();
   for (std::vector<gfx::ImageSkiaRep>::iterator iter = reps.begin();
       iter != reps.end(); ++iter) {
     copy.AddRepresentation(*iter);
   }
   return copy;
 }
 
+// For our scaling ratios we need to round positive numbers.
+int RoundPositive(double x) {
+  return static_cast<int>(floor(x + 0.5));
+}
+
 }  // namespace
 
 namespace chromeos {
 
 static WallpaperManager* g_wallpaper_manager = NULL;
 
 // WallpaperManager, public: ---------------------------------------------------
 
 // static
 WallpaperManager* WallpaperManager::Get() {
@@ skipping 48 matching lines @@
     GetLoggedInUserWallpaperProperties(&type, &index, &date);
 
     if (type == current_user_wallpaper_type_ &&
         index == current_user_wallpaper_index_) {
       return;
     }
   }
   SetUserWallpaper(UserManager::Get()->GetLoggedInUser().email());
 }
 
-void WallpaperManager::FetchCustomWallpaper(const std::string& email) {
+void WallpaperManager::GetCustomWallpaper(const std::string& email) {
   User::WallpaperType type;
   int index;
   base::Time date;
+  // Get layout, type and date while on UI thread.
   GetUserWallpaperProperties(email, &type, &index, &date);
   ash::WallpaperLayout layout = static_cast<ash::WallpaperLayout>(index);
-
-  std::string wallpaper_path = GetWallpaperPathForUser(email, false).value();
-
-  wallpaper_loader_->Start(wallpaper_path, 0,
-                           base::Bind(&WallpaperManager::FetchWallpaper,
-                                      base::Unretained(this), email, layout));
+  // Initializes file name to a dummy string here. The real file path will
+  // be set in GetCustomWallpaperInternal.
+  WallpaperInfo info = {
+      "DUMMY",
+      layout,
+      type,
+      date
+  };
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
+                 base::Unretained(this), email, info));
 }
 
 bool WallpaperManager::GetCustomWallpaperFromCache(const std::string& email,
                                                    gfx::ImageSkia* wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(email);
   if (it != wallpaper_cache_.end()) {
     *wallpaper = (*it).second;
     return true;
   }
   return false;
 }
 
+FilePath WallpaperManager::GetOriginalWallpaperPathForUser(
+    const std::string& username) {
+  std::string filename = username + "_wallpaper.png";
+  FilePath user_data_dir;
+  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+  return user_data_dir.AppendASCII(filename);
+}
+
 FilePath WallpaperManager::GetWallpaperPathForUser(const std::string& username,
-                                                   bool is_thumbnail) {
-  const char* suffix = is_thumbnail ? "_thumb" : "";
+                                                   bool is_small) {
+  const char* suffix = is_small ? "_small" : "_large";
   std::string filename = base::StringPrintf("%s_wallpaper%s.png",
                                             username.c_str(),
                                             suffix);
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   return user_data_dir.AppendASCII(filename);
 }
 
 gfx::ImageSkia WallpaperManager::GetCustomWallpaperThumbnail(
     const std::string& email) {
@@ skipping 169 matching lines @@
 void WallpaperManager::SetUserWallpaperFromFile(
     const std::string& username,
     const FilePath& path,
     ash::WallpaperLayout layout,
     base::WeakPtr<WallpaperDelegate> delegate) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // For wallpapers, save the image without resizing.
   wallpaper_loader_->Start(
       path.value(), 0,
-      base::Bind(&WallpaperManager::SetWallpaper,
+      base::Bind(&WallpaperManager::SetCustomWallpaper,
                  base::Unretained(this), username, layout, User::CUSTOMIZED,
                  delegate));
 }
 
 void WallpaperManager::SetInitialUserWallpaper(const std::string& username,
                                                bool is_persistent) {
   current_user_wallpaper_type_ = User::DEFAULT;
   if (username == kGuestUser)
     current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
   else
@@ skipping 61 matching lines @@
   if (!UserManager::Get()->IsKnownUser(email))
     return;
 
   bool new_wallpaper_ui_enabled = CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kEnableNewWallpaperUI);
 
   WallpaperInfo info;
 
   if (new_wallpaper_ui_enabled &&
       GetUserWallpaperInfo(email, &info)) {
+    if (info.type == User::CUSTOMIZED) {
+      if (!UserManager::Get()->IsUserLoggedIn()) {
+        ash::Shell::GetInstance()->desktop_background_controller()->
+            SetDefaultWallpaper(ash::GetDefaultWallpaperIndex(), false);
+      } else {
+        BrowserThread::PostTask(
+            BrowserThread::FILE, FROM_HERE,
+            base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
+                       base::Unretained(this), email, info));
+      }
+      return;
+    }
+
     if (info.file_name.empty()) {
       // Uses default built-in wallpaper when file name is empty. Eventually,
       // we will only ship one built-in wallpaper in ChromeOS image.
       ash::Shell::GetInstance()->desktop_background_controller()->
           SetDefaultWallpaper(ash::GetDefaultWallpaperIndex(), false);
       return;
     }
+
     LoadWallpaper(email, info);
   } else {
     User::WallpaperType type;
     int index;
     base::Time date;
     GetUserWallpaperProperties(email, &type, &index, &date);
     if (type == User::DAILY && date != base::Time::Now().LocalMidnight()) {
       index = ash::GetNextWallpaperIndex(index);
       SetUserWallpaperProperties(email, User::DAILY, index,
                                  ShouldPersistDataForUser(email));
     } else if (type == User::CUSTOMIZED) {
       // For security reason, use default wallpaper instead of custom wallpaper
       // at login screen. The security issue is tracked in issue 143198. Once it
       // fixed, we should then only use custom wallpaper.
       if (!UserManager::Get()->IsUserLoggedIn()) {
         index = ash::GetDefaultWallpaperIndex();
       } else {
-        FetchCustomWallpaper(email);
+        GetCustomWallpaper(email);
         return;
       }
     }
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(index, false);
     if (new_wallpaper_ui_enabled)
       MigrateBuiltInWallpaper(email);
   }
   SetLastSelectedUser(email);
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(
     const gfx::ImageSkia& wallpaper,
     ash::WallpaperLayout layout) {
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper, layout);
 }
 
 void WallpaperManager::OnUserSelected(const std::string& email) {
   SetUserWallpaper(email);
 }
 
 // WallpaperManager, private: --------------------------------------------------
 
 WallpaperManager::~WallpaperManager() {
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
   system::TimezoneSettings::GetInstance()->RemoveObserver(this);
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 void WallpaperManager::BatchUpdateWallpaper() {
   PrefService* local_state = g_browser_process->local_state();
   UserManager* user_manager = UserManager::Get();
   bool show_users = true;
   CrosSettings::Get()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn, &show_users);
   if (local_state) {
     User::WallpaperType type;
@@ skipping 52 matching lines @@
       FilePath wallpaper_path;
       if (info.type == User::CUSTOMIZED) {
         ash::Shell::GetInstance()->desktop_background_controller()->
             CacheDefaultWallpaper(ash::GetDefaultWallpaperIndex());
         return;
       }
       if (info.type == User::ONLINE) {
         CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS,
                                &wallpaper_dir));
         wallpaper_path = wallpaper_dir.Append(info.file_name);
-      } else {
+      } else if (info.type == User::DEFAULT) {
+        // Current wallpaper is converted from built-in wallpaper.
         ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
             desktop_background_controller()->GetAppropriateResolution();
         bool small_resolution = (resolution == ash::SMALL);
         wallpaper_path = GetWallpaperPathForUser(email, small_resolution);
+      } else {
+        // Cache default wallpaper when user selected a custom wallpaper.
+        ash::Shell::GetInstance()->desktop_background_controller()->
+            CacheDefaultWallpaper(ash::GetDefaultWallpaperIndex());
+        return;
       }
       wallpaper_loader_->Start(wallpaper_path.value(), 0,
                                base::Bind(&WallpaperManager::CacheWallpaper,
                                           base::Unretained(this), email));
     } else {
       MigrateBuiltInWallpaper(email);
       return;
     }
   } else {
     User::WallpaperType type;
@@ skipping 32 matching lines @@
 }
 
 void WallpaperManager::LoadWallpaper(const std::string& email,
                                      const WallpaperInfo& info) {
   FilePath wallpaper_dir;
   FilePath wallpaper_path;
   if (info.type == User::ONLINE) {
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     wallpaper_path = wallpaper_dir.Append(info.file_name);
   } else {
-    ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
-        desktop_background_controller()->GetAppropriateResolution();
-    bool small_resolution = (resolution == ash::SMALL);
-    wallpaper_path = GetWallpaperPathForUser(email, small_resolution);
+    FilePath user_data_dir;
+    PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+    wallpaper_path = user_data_dir.Append(info.file_name);
   }
 
   wallpaper_loader_->Start(wallpaper_path.value(), 0,
                            base::Bind(&WallpaperManager::FetchWallpaper,
                                       base::Unretained(this),
                                       email,
                                       info.layout));
 }
 
 void WallpaperManager::FetchWallpaper(const std::string& email,
@@ skipping 98 matching lines @@
   custom_wallpaper_thumbnail_cache_[email] = GetWallpaperThumbnail(wallpaper);
 
   // Notify thumbnail is ready.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WallpaperManager::OnThumbnailUpdated,
                  base::Unretained(this), delegate));
 }
 
+void WallpaperManager::GetCustomWallpaperInternal(const std::string& email,
+                                                  const WallpaperInfo& info) {
+  ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
+      desktop_background_controller()->GetAppropriateResolution();
+  bool is_small  = (resolution == ash::SMALL);
+  FilePath wallpaper_path = GetWallpaperPathForUser(email, is_small);
+  std::string file_name = wallpaper_path.BaseName().value();
+  // Falls back on original file if the correct resoltuion file does not
+  // exisit. This may happen when the original custom wallpaper is small or
+  // browser shutdown before resized wallpaper saved.
+  if (!file_util::PathExists(wallpaper_path))
+    file_name = GetOriginalWallpaperPathForUser(email).BaseName().value();
+
+  WallpaperInfo new_info = {
+      file_name,
+      info.layout,
+      info.type,
+      info.date
+  };
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&WallpaperManager::LoadWallpaper,
+                 base::Unretained(this), email, new_info));
+}
+
 void WallpaperManager::MigrateBuiltInWallpaper(const std::string& email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!email.empty() && UserManager::Get()->IsKnownUser(email)) {
     PrefService* prefs = g_browser_process->local_state();
     const DictionaryValue* user_wallpapers = prefs->
         GetDictionary(UserManager::kUserWallpapersProperties);
     const base::DictionaryValue* wallpaper_properties;
     User::WallpaperType type;
     int index;
     ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
@@ skipping 35 matching lines @@
 
         // Saves small wallpaper to user custom wallpaper thumbnail path.
         wallpaper_path = GetWallpaperPathForUser(email, true);
         BrowserThread::PostTask(
             BrowserThread::FILE,
             FROM_HERE,
             base::Bind(&WallpaperManager::SaveWallpaperInternal,
                    base::Unretained(this), wallpaper_path,
                    reinterpret_cast<const char*>(wallpaper->front()),
                    wallpaper->size()));
-      } else {
-        // Since we only have one resolution for custom wallpaper, always
-        // use LARGE resolution for custom wallpaper.
-        resolution = ash::LARGE;
       }
 
       bool small_resolution = (resolution == ash::SMALL);
       std::string file_name =
           GetWallpaperPathForUser(email, small_resolution).BaseName().value();
       WallpaperInfo info = {
                                file_name,
                                GetWallpaperViewInfo(index, resolution).layout,
                                type,
                                base::Time::Now().LocalMidnight()
                            };
       SetUserWallpaperInfo(email, info, true);
     }
   }
 }
 
 void WallpaperManager::OnThumbnailUpdated(
     base::WeakPtr<WallpaperDelegate> delegate) {
   if (delegate)
     delegate->SetCustomWallpaperThumbnail();
 }
 
-void WallpaperManager::SaveWallpaper(const FilePath& path,
-                                     const UserImage& wallpaper) {
+void WallpaperManager::OnWallpaperEncoded(const FilePath& path,
+    scoped_refptr<base::RefCountedBytes> data) {
+  SaveWallpaperInternal(path,
+                        reinterpret_cast<const char*>(data->front()),
+                        data->size());
+}
+
+void WallpaperManager::SaveCustomWallpaper(const std::string& email,
+                                           const FilePath& path,
+                                           ash::WallpaperLayout layout,
+                                           const UserImage& wallpaper) {
+  FilePath small_wallpaper_path = GetWallpaperPathForUser(email, true);
+  // Delete previous saved wallpapers.
+  if (file_util::PathExists(small_wallpaper_path))
+    file_util::Delete(small_wallpaper_path, false);
+  FilePath large_wallpaper_path = GetWallpaperPathForUser(email, false);
+  if (file_util::PathExists(large_wallpaper_path))
+    file_util::Delete(large_wallpaper_path, false);
+
   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(path, reinterpret_cast<char*>(&*image_data.begin()),
                         image_data.size());
+
+  ResizeAndSaveCustomWallpaper(wallpaper, small_wallpaper_path, layout,
+                               ash::kSmallWallpaperMaximalWidth,
+                               ash::kSmallWallpaperMaximalHeight);
+  ResizeAndSaveCustomWallpaper(wallpaper, large_wallpaper_path, layout,
+                               ash::kLargeWallpaperMaximalWidth,
+                               ash::kLargeWallpaperMaximalHeight);
+}
+
+void WallpaperManager::ResizeAndSaveCustomWallpaper(const UserImage& wallpaper,
+                                                    const FilePath& path,
+                                                    ash::WallpaperLayout layout,
+                                                    int preferred_width,
+                                                    int preferred_height) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  int width = wallpaper.image().width();
+  int height = wallpaper.image().height();
+  int resized_width;
+  int resized_height;
+
+  if (layout == ash::CENTER_CROPPED) {
+    // Do not resize custom wallpaper if it is smaller than preferred size.
+    if (!(width > preferred_width && height > preferred_height))
+      return;
+
+    double horizontal_ratio = static_cast<double>(preferred_width) /
+        static_cast<double>(width);
+    double vertical_ratio = static_cast<double>(preferred_height) /
+        static_cast<double>(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::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;
+  }
+
+  gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
+      wallpaper.image(),
+      skia::ImageOperations::RESIZE_LANCZOS3,
+      gfx::Size(resized_width, resized_height));
+
+  scoped_refptr<base::RefCountedBytes> data = new base::RefCountedBytes();
+  // Uses simple png encoder to encode image on worker pool. So we do not block
+  // chrome shutdown on image encoding.
+  SimplePngEncoder* png_encoder = new SimplePngEncoder(
+      data, *(resized_image.bitmap()));
+  png_encoder->Run(
+      base::Bind(&WallpaperManager::OnWallpaperEncoded,
+                 weak_factory_.GetWeakPtr(),
+                 path));
 }
 
 void WallpaperManager::SaveWallpaperInternal(const FilePath& path,
                                              const char* data,
                                              int size) {
   int written_bytes = file_util::WriteFile(path, data, size);
   DCHECK(written_bytes == size);
 }
 
-void WallpaperManager::SetWallpaper(const std::string& username,
-                                    ash::WallpaperLayout layout,
-                                    User::WallpaperType type,
-                                    base::WeakPtr<WallpaperDelegate> delegate,
-                                    const UserImage& wallpaper) {
+void WallpaperManager::SetCustomWallpaper(const std::string& username,
+    ash::WallpaperLayout layout,
+    User::WallpaperType type,
+    base::WeakPtr<WallpaperDelegate> delegate,
+    const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string wallpaper_path =
-      GetWallpaperPathForUser(username, false).value();
+      GetOriginalWallpaperPathForUser(username).value();
 
   bool is_persistent = ShouldPersistDataForUser(username);
 
-  if (is_persistent) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&WallpaperManager::SaveWallpaper,
-                   base::Unretained(this),
-                   FilePath(wallpaper_path),
-                   wallpaper));
-  }
-
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WallpaperManager::GenerateUserWallpaperThumbnail,
                  base::Unretained(this), username, type, delegate,
                  wallpaper.image()));
 
+  if (is_persistent) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&WallpaperManager::SaveCustomWallpaper,
+                   base::Unretained(this),
+                   username,
+                   FilePath(wallpaper_path),
+                   layout,
+                   wallpaper));
+  }
+
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper.image(), layout);
   SetUserWallpaperProperties(username, type, layout, is_persistent);
 }
 
 bool WallpaperManager::ShouldPersistDataForUser(const std::string& email) {
   UserManager* user_manager = UserManager::Get();
   // |email| is from user list in local state. We should persist data in this
   // case.
   if (!user_manager->IsUserLoggedIn())
     return true;
   return !(email == user_manager->GetLoggedInUser().email() &&
            user_manager->IsCurrentUserEphemeral());
 }
 
 void WallpaperManager::OnWallpaperLoaded(ash::WallpaperLayout layout,
                                          const UserImage& user_image) {
   SetWallpaperFromImageSkia(user_image.image(), layout);
 }
 
 void WallpaperManager::SystemResumed() {
   BatchUpdateWallpaper();
 }
 
 void WallpaperManager::TimezoneChanged(const icu::TimeZone& timezone) {
   RestartTimer();
 }
 
 }  // chromeos