Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/chromeos/extensions/wallpaper_private_api.h"
      6 
      7 #include <vector>
      8 
      9 #include "ash/ash_switches.h"
     10 #include "ash/desktop_background/desktop_background_controller.h"
     11 #include "ash/shell.h"
     12 #include "ash/wm/mru_window_tracker.h"
     13 #include "ash/wm/window_state.h"
     14 #include "ash/wm/window_util.h"
     15 #include "base/command_line.h"
     16 #include "base/files/file_enumerator.h"
     17 #include "base/files/file_util.h"
     18 #include "base/memory/scoped_ptr.h"
     19 #include "base/path_service.h"
     20 #include "base/prefs/pref_service.h"
     21 #include "base/strings/string_number_conversions.h"
     22 #include "base/strings/stringprintf.h"
     23 #include "base/threading/worker_pool.h"
     24 #include "chrome/browser/browser_process.h"
     25 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
     26 #include "chrome/browser/profiles/profile.h"
     27 #include "chrome/common/chrome_paths.h"
     28 #include "chrome/common/pref_names.h"
     29 #include "chrome/grit/generated_resources.h"
     30 #include "components/user_manager/user.h"
     31 #include "components/user_manager/user_manager.h"
     32 #include "content/public/browser/browser_thread.h"
     33 #include "extensions/browser/event_router.h"
     34 #include "grit/components_strings.h"
     35 #include "ui/base/l10n/l10n_util.h"
     36 #include "ui/base/webui/web_ui_util.h"
     37 #include "ui/strings/grit/app_locale_settings.h"
     38 #include "url/gurl.h"
     39 
     40 using base::BinaryValue;
     41 using content::BrowserThread;
     42 namespace wallpaper_private = extensions::api::wallpaper_private;
     43 namespace set_wallpaper_if_exists = wallpaper_private::SetWallpaperIfExists;
     44 namespace set_wallpaper = wallpaper_private::SetWallpaper;
     45 namespace set_custom_wallpaper = wallpaper_private::SetCustomWallpaper;
     46 namespace set_custom_wallpaper_layout =
     47     wallpaper_private::SetCustomWallpaperLayout;
     48 namespace get_thumbnail = wallpaper_private::GetThumbnail;
     49 namespace save_thumbnail = wallpaper_private::SaveThumbnail;
     50 namespace get_offline_wallpaper_list =
     51     wallpaper_private::GetOfflineWallpaperList;
     52 
     53 namespace {
     54 
     55 #if defined(GOOGLE_CHROME_BUILD)
     56 const char kWallpaperManifestBaseURL[] =
     57     "https://storage.googleapis.com/chromeos-wallpaper-public/manifest_";
     58 #endif
     59 
     60 bool IsOEMDefaultWallpaper() {
     61   return CommandLine::ForCurrentProcess()->HasSwitch(
     62       ash::switches::kAshDefaultWallpaperIsOem);
     63 }
     64 
     65 // Saves |data| as |file_name| to directory with |key|. Return false if the
     66 // directory can not be found/created or failed to write file.
     67 bool SaveData(int key, const std::string& file_name, const std::string& data) {
     68   base::FilePath data_dir;
     69   CHECK(PathService::Get(key, &data_dir));
     70   if (!base::DirectoryExists(data_dir) &&
     71       !base::CreateDirectory(data_dir)) {
     72     return false;
     73   }
     74   base::FilePath file_path = data_dir.Append(file_name);
     75 
     76   return base::PathExists(file_path) ||
     77          (base::WriteFile(file_path, data.c_str(), data.size()) != -1);
     78 }
     79 
     80 // Gets |file_name| from directory with |key|. Return false if the directory can
     81 // not be found or failed to read file to string |data|. Note if the |file_name|
     82 // can not be found in the directory, return true with empty |data|. It is
     83 // expected that we may try to access file which did not saved yet.
     84 bool GetData(const base::FilePath& path, std::string* data) {
     85   base::FilePath data_dir = path.DirName();
     86   if (!base::DirectoryExists(data_dir) &&
     87       !base::CreateDirectory(data_dir))
     88     return false;
     89 
     90   return !base::PathExists(path) ||
     91          base::ReadFileToString(path, data);
     92 }
     93 
     94 // WindowStateManager remembers which windows have been minimized in order to
     95 // restore them when the wallpaper viewer is hidden.
     96 class WindowStateManager : public aura::WindowObserver {
     97  public:
     98   typedef std::map<std::string, std::set<aura::Window*> >
     99       UserIDHashWindowListMap;
    100 
    101   // Minimizes all windows except the active window.
    102   static void MinimizeInactiveWindows(const std::string& user_id_hash);
    103 
    104   // Unminimizes all minimized windows restoring them to their previous state.
    105   // This should only be called after calling MinimizeInactiveWindows.
    106   static void RestoreWindows(const std::string& user_id_hash);
    107 
    108  private:
    109   WindowStateManager();
    110 
    111   virtual ~WindowStateManager();
    112 
    113   // Store all unminimized windows except |active_window| and minimize them.
    114   // All the windows are saved in a map and the key value is |user_id_hash|.
    115   void BuildWindowListAndMinimizeInactiveForUser(
    116       const std::string& user_id_hash, aura::Window* active_window);
    117 
    118   // Unminimize all the stored windows for |user_id_hash|.
    119   void RestoreMinimizedWindows(const std::string& user_id_hash);
    120 
    121   // Remove the observer from |window| if |window| is no longer referenced in
    122   // user_id_hash_window_list_map_.
    123   void RemoveObserverIfUnreferenced(aura::Window* window);
    124 
    125   // aura::WindowObserver overrides.
    126   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
    127 
    128   // Map of user id hash and associated list of minimized windows.
    129   UserIDHashWindowListMap user_id_hash_window_list_map_;
    130 
    131   DISALLOW_COPY_AND_ASSIGN(WindowStateManager);
    132 };
    133 
    134 // static
    135 WindowStateManager* g_window_state_manager = NULL;
    136 
    137 // static
    138 void WindowStateManager::MinimizeInactiveWindows(
    139     const std::string& user_id_hash) {
    140   if (!g_window_state_manager)
    141     g_window_state_manager = new WindowStateManager();
    142   g_window_state_manager->BuildWindowListAndMinimizeInactiveForUser(
    143       user_id_hash, ash::wm::GetActiveWindow());
    144 }
    145 
    146 // static
    147 void WindowStateManager::RestoreWindows(const std::string& user_id_hash) {
    148   if (!g_window_state_manager) {
    149     DCHECK(false) << "This should only be called after calling "
    150                   << "MinimizeInactiveWindows.";
    151     return;
    152   }
    153 
    154   g_window_state_manager->RestoreMinimizedWindows(user_id_hash);
    155   if (g_window_state_manager->user_id_hash_window_list_map_.empty()) {
    156     delete g_window_state_manager;
    157     g_window_state_manager = NULL;
    158   }
    159 }
    160 
    161 WindowStateManager::WindowStateManager() {}
    162 
    163 WindowStateManager::~WindowStateManager() {}
    164 
    165 void WindowStateManager::BuildWindowListAndMinimizeInactiveForUser(
    166     const std::string& user_id_hash, aura::Window* active_window) {
    167   if (user_id_hash_window_list_map_.find(user_id_hash) ==
    168       user_id_hash_window_list_map_.end()) {
    169     user_id_hash_window_list_map_[user_id_hash] = std::set<aura::Window*>();
    170   }
    171   std::set<aura::Window*>* results =
    172       &user_id_hash_window_list_map_[user_id_hash];
    173 
    174   std::vector<aura::Window*> windows =
    175       ash::MruWindowTracker::BuildWindowList(false);
    176 
    177   for (std::vector<aura::Window*>::iterator iter = windows.begin();
    178        iter != windows.end(); ++iter) {
    179     // Ignore active window and minimized windows.
    180     if (*iter == active_window || ash::wm::GetWindowState(*iter)->IsMinimized())
    181       continue;
    182 
    183     // TODO(bshe): Add WindowStateObserver too. http://crbug.com/323252
    184     if (!(*iter)->HasObserver(this))
    185       (*iter)->AddObserver(this);
    186 
    187     results->insert(*iter);
    188     ash::wm::GetWindowState(*iter)->Minimize();
    189   }
    190 }
    191 
    192 void WindowStateManager::RestoreMinimizedWindows(
    193     const std::string& user_id_hash) {
    194   UserIDHashWindowListMap::iterator it =
    195       user_id_hash_window_list_map_.find(user_id_hash);
    196   if (it == user_id_hash_window_list_map_.end()) {
    197     DCHECK(false) << "This should only be called after calling "
    198                   << "MinimizeInactiveWindows.";
    199     return;
    200   }
    201 
    202   std::set<aura::Window*> removed_windows;
    203   removed_windows.swap(it->second);
    204   user_id_hash_window_list_map_.erase(it);
    205 
    206   for (std::set<aura::Window*>::iterator iter = removed_windows.begin();
    207        iter != removed_windows.end(); ++iter) {
    208     ash::wm::GetWindowState(*iter)->Unminimize();
    209     RemoveObserverIfUnreferenced(*iter);
    210   }
    211 }
    212 
    213 void WindowStateManager::RemoveObserverIfUnreferenced(aura::Window* window) {
    214   for (UserIDHashWindowListMap::iterator iter =
    215            user_id_hash_window_list_map_.begin();
    216        iter != user_id_hash_window_list_map_.end();
    217        ++iter) {
    218     if (iter->second.find(window) != iter->second.end())
    219       return;
    220   }
    221   // Remove observer if |window| is not observed by any users.
    222   window->RemoveObserver(this);
    223 }
    224 
    225 void WindowStateManager::OnWindowDestroyed(aura::Window* window) {
    226   for (UserIDHashWindowListMap::iterator iter =
    227            user_id_hash_window_list_map_.begin();
    228        iter != user_id_hash_window_list_map_.end();
    229        ++iter) {
    230     iter->second.erase(window);
    231   }
    232 }
    233 
    234 }  // namespace
    235 
    236 bool WallpaperPrivateGetStringsFunction::RunSync() {
    237   base::DictionaryValue* dict = new base::DictionaryValue();
    238   SetResult(dict);
    239 
    240 #define SET_STRING(id, idr) \
    241   dict->SetString(id, l10n_util::GetStringUTF16(idr))
    242   SET_STRING("webFontFamily", IDS_WEB_FONT_FAMILY);
    243   SET_STRING("webFontSize", IDS_WEB_FONT_SIZE);
    244   SET_STRING("allCategoryLabel", IDS_WALLPAPER_MANAGER_ALL_CATEGORY_LABEL);
    245   SET_STRING("deleteCommandLabel", IDS_WALLPAPER_MANAGER_DELETE_COMMAND_LABEL);
    246   SET_STRING("customCategoryLabel",
    247              IDS_WALLPAPER_MANAGER_CUSTOM_CATEGORY_LABEL);
    248   SET_STRING("selectCustomLabel",
    249              IDS_WALLPAPER_MANAGER_SELECT_CUSTOM_LABEL);
    250   SET_STRING("positionLabel", IDS_WALLPAPER_MANAGER_POSITION_LABEL);
    251   SET_STRING("colorLabel", IDS_WALLPAPER_MANAGER_COLOR_LABEL);
    252   SET_STRING("centerCroppedLayout",
    253              IDS_OPTIONS_WALLPAPER_CENTER_CROPPED_LAYOUT);
    254   SET_STRING("centerLayout", IDS_OPTIONS_WALLPAPER_CENTER_LAYOUT);
    255   SET_STRING("stretchLayout", IDS_OPTIONS_WALLPAPER_STRETCH_LAYOUT);
    256   SET_STRING("connectionFailed", IDS_WALLPAPER_MANAGER_ACCESS_FAIL);
    257   SET_STRING("downloadFailed", IDS_WALLPAPER_MANAGER_DOWNLOAD_FAIL);
    258   SET_STRING("downloadCanceled", IDS_WALLPAPER_MANAGER_DOWNLOAD_CANCEL);
    259   SET_STRING("customWallpaperWarning",
    260              IDS_WALLPAPER_MANAGER_SHOW_CUSTOM_WALLPAPER_ON_START_WARNING);
    261   SET_STRING("accessFileFailure", IDS_WALLPAPER_MANAGER_ACCESS_FILE_FAILURE);
    262   SET_STRING("invalidWallpaper", IDS_WALLPAPER_MANAGER_INVALID_WALLPAPER);
    263   SET_STRING("surpriseMeLabel", IDS_WALLPAPER_MANAGER_SURPRISE_ME_LABEL);
    264   SET_STRING("learnMore", IDS_LEARN_MORE);
    265   SET_STRING("currentWallpaperSetByMessage",
    266              IDS_CURRENT_WALLPAPER_SET_BY_MESSAGE);
    267 #undef SET_STRING
    268 
    269   webui::SetFontAndTextDirection(dict);
    270 
    271   chromeos::WallpaperManager* wallpaper_manager =
    272       chromeos::WallpaperManager::Get();
    273   chromeos::WallpaperInfo info;
    274 
    275   if (wallpaper_manager->GetLoggedInUserWallpaperInfo(&info))
    276     dict->SetString("currentWallpaper", info.location);
    277 
    278 #if defined(GOOGLE_CHROME_BUILD)
    279   dict->SetString("manifestBaseURL", kWallpaperManifestBaseURL);
    280 #endif
    281 
    282   Profile* profile = Profile::FromBrowserContext(browser_context());
    283   std::string app_name(
    284       profile->GetPrefs()->GetString(prefs::kCurrentWallpaperAppName));
    285   if (!app_name.empty())
    286     dict->SetString("wallpaperAppName", app_name);
    287 
    288   dict->SetBoolean("isOEMDefaultWallpaper", IsOEMDefaultWallpaper());
    289   dict->SetString("canceledWallpaper",
    290                   wallpaper_api_util::kCancelWallpaperMessage);
    291   return true;
    292 }
    293 
    294 WallpaperPrivateSetWallpaperIfExistsFunction::
    295     WallpaperPrivateSetWallpaperIfExistsFunction() {}
    296 
    297 WallpaperPrivateSetWallpaperIfExistsFunction::
    298     ~WallpaperPrivateSetWallpaperIfExistsFunction() {}
    299 
    300 bool WallpaperPrivateSetWallpaperIfExistsFunction::RunAsync() {
    301 #if !defined(USE_ATHENA)
    302   // TODO(bshe): Support wallpaper manager in Athena, crbug.com/408734.
    303   params = set_wallpaper_if_exists::Params::Create(*args_);
    304   EXTENSION_FUNCTION_VALIDATE(params);
    305 
    306   user_id_ = user_manager::UserManager::Get()->GetActiveUser()->email();
    307 
    308   base::FilePath wallpaper_path;
    309   base::FilePath fallback_path;
    310   chromeos::WallpaperManager::WallpaperResolution resolution =
    311       chromeos::WallpaperManager::GetAppropriateResolution();
    312 
    313   std::string file_name = GURL(params->url).ExtractFileName();
    314   CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS,
    315                          &wallpaper_path));
    316   fallback_path = wallpaper_path.Append(file_name);
    317   if (params->layout != wallpaper_private::WALLPAPER_LAYOUT_STRETCH &&
    318       resolution == chromeos::WallpaperManager::WALLPAPER_RESOLUTION_SMALL) {
    319     file_name = base::FilePath(file_name).InsertBeforeExtension(
    320         chromeos::kSmallWallpaperSuffix).value();
    321   }
    322   wallpaper_path = wallpaper_path.Append(file_name);
    323 
    324   sequence_token_ = BrowserThread::GetBlockingPool()->
    325       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    326   scoped_refptr<base::SequencedTaskRunner> task_runner =
    327       BrowserThread::GetBlockingPool()->
    328           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    329               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
    330 
    331   task_runner->PostTask(FROM_HERE,
    332       base::Bind(
    333           &WallpaperPrivateSetWallpaperIfExistsFunction::
    334               ReadFileAndInitiateStartDecode,
    335           this, wallpaper_path, fallback_path));
    336 #endif
    337   return true;
    338 }
    339 
    340 void WallpaperPrivateSetWallpaperIfExistsFunction::
    341     ReadFileAndInitiateStartDecode(const base::FilePath& file_path,
    342                                    const base::FilePath& fallback_path) {
    343   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    344       sequence_token_));
    345   std::string data;
    346   base::FilePath path = file_path;
    347 
    348   if (!base::PathExists(file_path))
    349     path = fallback_path;
    350 
    351   if (base::PathExists(path) &&
    352       base::ReadFileToString(path, &data)) {
    353     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
    354         base::Bind(&WallpaperPrivateSetWallpaperIfExistsFunction::StartDecode,
    355                    this, data));
    356     return;
    357   }
    358   std::string error = base::StringPrintf(
    359         "Failed to set wallpaper %s from file system.",
    360         path.BaseName().value().c_str());
    361   BrowserThread::PostTask(
    362       BrowserThread::UI, FROM_HERE,
    363       base::Bind(&WallpaperPrivateSetWallpaperIfExistsFunction::OnFileNotExists,
    364                  this, error));
    365 }
    366 
    367 void WallpaperPrivateSetWallpaperIfExistsFunction::OnWallpaperDecoded(
    368     const gfx::ImageSkia& image) {
    369   // Set unsafe_wallpaper_decoder_ to null since the decoding already finished.
    370   unsafe_wallpaper_decoder_ = NULL;
    371 
    372   chromeos::WallpaperManager* wallpaper_manager =
    373       chromeos::WallpaperManager::Get();
    374   ash::WallpaperLayout layout = wallpaper_api_util::GetLayoutEnum(
    375       wallpaper_private::ToString(params->layout));
    376 
    377   bool update_wallpaper =
    378       user_id_ == user_manager::UserManager::Get()->GetActiveUser()->email();
    379   wallpaper_manager->SetWallpaperFromImageSkia(
    380       user_id_, image, layout, update_wallpaper);
    381   bool is_persistent = !user_manager::UserManager::Get()
    382                             ->IsCurrentUserNonCryptohomeDataEphemeral();
    383   chromeos::WallpaperInfo info = {params->url, layout,
    384                                   user_manager::User::ONLINE,
    385                                   base::Time::Now().LocalMidnight()};
    386   wallpaper_manager->SetUserWallpaperInfo(user_id_, info, is_persistent);
    387   SetResult(new base::FundamentalValue(true));
    388   Profile* profile = Profile::FromBrowserContext(browser_context());
    389   // This API is only available to the component wallpaper picker. We do not
    390   // need to show the app's name if it is the component wallpaper picker. So set
    391   // the pref to empty string.
    392   profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
    393                                  std::string());
    394   SendResponse(true);
    395 }
    396 
    397 void WallpaperPrivateSetWallpaperIfExistsFunction::OnFileNotExists(
    398     const std::string& error) {
    399   SetResult(new base::FundamentalValue(false));
    400   OnFailure(error);
    401 }
    402 
    403 WallpaperPrivateSetWallpaperFunction::WallpaperPrivateSetWallpaperFunction() {
    404 }
    405 
    406 WallpaperPrivateSetWallpaperFunction::~WallpaperPrivateSetWallpaperFunction() {
    407 }
    408 
    409 bool WallpaperPrivateSetWallpaperFunction::RunAsync() {
    410   params = set_wallpaper::Params::Create(*args_);
    411   EXTENSION_FUNCTION_VALIDATE(params);
    412 
    413   // Gets email address while at UI thread.
    414   user_id_ = user_manager::UserManager::Get()->GetActiveUser()->email();
    415 
    416   StartDecode(params->wallpaper);
    417 
    418   return true;
    419 }
    420 
    421 void WallpaperPrivateSetWallpaperFunction::OnWallpaperDecoded(
    422     const gfx::ImageSkia& image) {
    423   wallpaper_ = image;
    424   // Set unsafe_wallpaper_decoder_ to null since the decoding already finished.
    425   unsafe_wallpaper_decoder_ = NULL;
    426 
    427   sequence_token_ = BrowserThread::GetBlockingPool()->
    428       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    429   scoped_refptr<base::SequencedTaskRunner> task_runner =
    430       BrowserThread::GetBlockingPool()->
    431           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    432               base::SequencedWorkerPool::BLOCK_SHUTDOWN);
    433 
    434   task_runner->PostTask(FROM_HERE,
    435       base::Bind(&WallpaperPrivateSetWallpaperFunction::SaveToFile, this));
    436 }
    437 
    438 void WallpaperPrivateSetWallpaperFunction::SaveToFile() {
    439   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    440       sequence_token_));
    441   std::string file_name = GURL(params->url).ExtractFileName();
    442   if (SaveData(chrome::DIR_CHROMEOS_WALLPAPERS, file_name, params->wallpaper)) {
    443     wallpaper_.EnsureRepsForSupportedScales();
    444     scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper_.DeepCopy());
    445     // ImageSkia is not RefCountedThreadSafe. Use a deep copied ImageSkia if
    446     // post to another thread.
    447     BrowserThread::PostTask(
    448         BrowserThread::UI,
    449         FROM_HERE,
    450         base::Bind(&WallpaperPrivateSetWallpaperFunction::SetDecodedWallpaper,
    451                    this,
    452                    base::Passed(deep_copy.Pass())));
    453 
    454     base::FilePath wallpaper_dir;
    455     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
    456     base::FilePath file_path = wallpaper_dir.Append(
    457         file_name).InsertBeforeExtension(chromeos::kSmallWallpaperSuffix);
    458     if (base::PathExists(file_path))
    459       return;
    460     // Generates and saves small resolution wallpaper. Uses CENTER_CROPPED to
    461     // maintain the aspect ratio after resize.
    462     chromeos::WallpaperManager::Get()->ResizeAndSaveWallpaper(
    463         wallpaper_,
    464         file_path,
    465         ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
    466         chromeos::kSmallWallpaperMaxWidth,
    467         chromeos::kSmallWallpaperMaxHeight,
    468         NULL);
    469   } else {
    470     std::string error = base::StringPrintf(
    471         "Failed to create/write wallpaper to %s.", file_name.c_str());
    472     BrowserThread::PostTask(
    473         BrowserThread::UI, FROM_HERE,
    474         base::Bind(&WallpaperPrivateSetWallpaperFunction::OnFailure,
    475                    this, error));
    476   }
    477 }
    478 
    479 void WallpaperPrivateSetWallpaperFunction::SetDecodedWallpaper(
    480     scoped_ptr<gfx::ImageSkia> image) {
    481   chromeos::WallpaperManager* wallpaper_manager =
    482       chromeos::WallpaperManager::Get();
    483 
    484   ash::WallpaperLayout layout = wallpaper_api_util::GetLayoutEnum(
    485       wallpaper_private::ToString(params->layout));
    486 
    487   bool update_wallpaper =
    488       user_id_ == user_manager::UserManager::Get()->GetActiveUser()->email();
    489   wallpaper_manager->SetWallpaperFromImageSkia(
    490       user_id_, *image.get(), layout, update_wallpaper);
    491 
    492   bool is_persistent = !user_manager::UserManager::Get()
    493                             ->IsCurrentUserNonCryptohomeDataEphemeral();
    494   chromeos::WallpaperInfo info = {params->url, layout,
    495                                   user_manager::User::ONLINE,
    496                                   base::Time::Now().LocalMidnight()};
    497   Profile* profile = Profile::FromBrowserContext(browser_context());
    498   // This API is only available to the component wallpaper picker. We do not
    499   // need to show the app's name if it is the component wallpaper picker. So set
    500   // the pref to empty string.
    501   profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
    502                                  std::string());
    503   wallpaper_manager->SetUserWallpaperInfo(user_id_, info, is_persistent);
    504   SendResponse(true);
    505 }
    506 
    507 WallpaperPrivateResetWallpaperFunction::
    508     WallpaperPrivateResetWallpaperFunction() {}
    509 
    510 WallpaperPrivateResetWallpaperFunction::
    511     ~WallpaperPrivateResetWallpaperFunction() {}
    512 
    513 bool WallpaperPrivateResetWallpaperFunction::RunAsync() {
    514   chromeos::WallpaperManager* wallpaper_manager =
    515       chromeos::WallpaperManager::Get();
    516   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
    517 
    518   std::string user_id = user_manager->GetActiveUser()->email();
    519   wallpaper_manager->RemoveUserWallpaperInfo(user_id);
    520 
    521   chromeos::WallpaperInfo info = {std::string(),
    522                                   ash::WALLPAPER_LAYOUT_CENTER,
    523                                   user_manager::User::DEFAULT,
    524                                   base::Time::Now().LocalMidnight()};
    525   bool is_persistent =
    526       !user_manager->IsCurrentUserNonCryptohomeDataEphemeral();
    527   wallpaper_manager->SetUserWallpaperInfo(user_id, info, is_persistent);
    528 
    529   wallpaper_manager->SetDefaultWallpaperNow(user_id);
    530   Profile* profile = Profile::FromBrowserContext(browser_context());
    531   // This API is only available to the component wallpaper picker. We do not
    532   // need to show the app's name if it is the component wallpaper picker. So set
    533   // the pref to empty string.
    534   profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
    535                                  std::string());
    536   return true;
    537 }
    538 
    539 WallpaperPrivateSetCustomWallpaperFunction::
    540     WallpaperPrivateSetCustomWallpaperFunction() {}
    541 
    542 WallpaperPrivateSetCustomWallpaperFunction::
    543     ~WallpaperPrivateSetCustomWallpaperFunction() {}
    544 
    545 bool WallpaperPrivateSetCustomWallpaperFunction::RunAsync() {
    546   params = set_custom_wallpaper::Params::Create(*args_);
    547   EXTENSION_FUNCTION_VALIDATE(params);
    548 
    549   // Gets email address and username hash while at UI thread.
    550   user_id_ = user_manager::UserManager::Get()->GetActiveUser()->email();
    551   user_id_hash_ =
    552       user_manager::UserManager::Get()->GetActiveUser()->username_hash();
    553 
    554   StartDecode(params->wallpaper);
    555 
    556   return true;
    557 }
    558 
    559 void WallpaperPrivateSetCustomWallpaperFunction::OnWallpaperDecoded(
    560     const gfx::ImageSkia& image) {
    561   chromeos::WallpaperManager* wallpaper_manager =
    562       chromeos::WallpaperManager::Get();
    563   base::FilePath thumbnail_path = wallpaper_manager->GetCustomWallpaperPath(
    564       chromeos::kThumbnailWallpaperSubDir, user_id_hash_, params->file_name);
    565 
    566   sequence_token_ = BrowserThread::GetBlockingPool()->
    567       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    568   scoped_refptr<base::SequencedTaskRunner> task_runner =
    569       BrowserThread::GetBlockingPool()->
    570           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    571               base::SequencedWorkerPool::BLOCK_SHUTDOWN);
    572 
    573   ash::WallpaperLayout layout = wallpaper_api_util::GetLayoutEnum(
    574       wallpaper_private::ToString(params->layout));
    575 
    576   bool update_wallpaper =
    577       user_id_ == user_manager::UserManager::Get()->GetActiveUser()->email();
    578   wallpaper_manager->SetCustomWallpaper(user_id_,
    579                                         user_id_hash_,
    580                                         params->file_name,
    581                                         layout,
    582                                         user_manager::User::CUSTOMIZED,
    583                                         image,
    584                                         update_wallpaper);
    585   unsafe_wallpaper_decoder_ = NULL;
    586 
    587   Profile* profile = Profile::FromBrowserContext(browser_context());
    588   // This API is only available to the component wallpaper picker. We do not
    589   // need to show the app's name if it is the component wallpaper picker. So set
    590   // the pref to empty string.
    591   profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
    592                                  std::string());
    593 
    594   if (params->generate_thumbnail) {
    595     image.EnsureRepsForSupportedScales();
    596     scoped_ptr<gfx::ImageSkia> deep_copy(image.DeepCopy());
    597     // Generates thumbnail before call api function callback. We can then
    598     // request thumbnail in the javascript callback.
    599     task_runner->PostTask(FROM_HERE,
    600         base::Bind(
    601             &WallpaperPrivateSetCustomWallpaperFunction::GenerateThumbnail,
    602             this, thumbnail_path, base::Passed(&deep_copy)));
    603   } else {
    604     SendResponse(true);
    605   }
    606 }
    607 
    608 void WallpaperPrivateSetCustomWallpaperFunction::GenerateThumbnail(
    609     const base::FilePath& thumbnail_path, scoped_ptr<gfx::ImageSkia> image) {
    610   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    611       sequence_token_));
    612   if (!base::PathExists(thumbnail_path.DirName()))
    613     base::CreateDirectory(thumbnail_path.DirName());
    614 
    615   scoped_refptr<base::RefCountedBytes> data;
    616   chromeos::WallpaperManager::Get()->ResizeImage(
    617       *image,
    618       ash::WALLPAPER_LAYOUT_STRETCH,
    619       chromeos::kWallpaperThumbnailWidth,
    620       chromeos::kWallpaperThumbnailHeight,
    621       &data,
    622       NULL);
    623   BrowserThread::PostTask(
    624         BrowserThread::UI, FROM_HERE,
    625         base::Bind(
    626             &WallpaperPrivateSetCustomWallpaperFunction::ThumbnailGenerated,
    627             this, data));
    628 }
    629 
    630 void WallpaperPrivateSetCustomWallpaperFunction::ThumbnailGenerated(
    631     base::RefCountedBytes* data) {
    632   BinaryValue* result = BinaryValue::CreateWithCopiedBuffer(
    633       reinterpret_cast<const char*>(data->front()), data->size());
    634   SetResult(result);
    635   SendResponse(true);
    636 }
    637 
    638 WallpaperPrivateSetCustomWallpaperLayoutFunction::
    639     WallpaperPrivateSetCustomWallpaperLayoutFunction() {}
    640 
    641 WallpaperPrivateSetCustomWallpaperLayoutFunction::
    642     ~WallpaperPrivateSetCustomWallpaperLayoutFunction() {}
    643 
    644 bool WallpaperPrivateSetCustomWallpaperLayoutFunction::RunAsync() {
    645   scoped_ptr<set_custom_wallpaper_layout::Params> params(
    646       set_custom_wallpaper_layout::Params::Create(*args_));
    647   EXTENSION_FUNCTION_VALIDATE(params);
    648 
    649   chromeos::WallpaperManager* wallpaper_manager =
    650       chromeos::WallpaperManager::Get();
    651   chromeos::WallpaperInfo info;
    652   wallpaper_manager->GetLoggedInUserWallpaperInfo(&info);
    653   if (info.type != user_manager::User::CUSTOMIZED) {
    654     SetError("Only custom wallpaper can change layout.");
    655     SendResponse(false);
    656     return false;
    657   }
    658   info.layout = wallpaper_api_util::GetLayoutEnum(
    659       wallpaper_private::ToString(params->layout));
    660 
    661   std::string email =
    662       user_manager::UserManager::Get()->GetActiveUser()->email();
    663   bool is_persistent = !user_manager::UserManager::Get()
    664                             ->IsCurrentUserNonCryptohomeDataEphemeral();
    665   wallpaper_manager->SetUserWallpaperInfo(email, info, is_persistent);
    666   wallpaper_manager->UpdateWallpaper(false /* clear_cache */);
    667   SendResponse(true);
    668 
    669   // Gets email address while at UI thread.
    670   return true;
    671 }
    672 
    673 WallpaperPrivateMinimizeInactiveWindowsFunction::
    674     WallpaperPrivateMinimizeInactiveWindowsFunction() {
    675 }
    676 
    677 WallpaperPrivateMinimizeInactiveWindowsFunction::
    678     ~WallpaperPrivateMinimizeInactiveWindowsFunction() {
    679 }
    680 
    681 bool WallpaperPrivateMinimizeInactiveWindowsFunction::RunAsync() {
    682   WindowStateManager::MinimizeInactiveWindows(
    683       user_manager::UserManager::Get()->GetActiveUser()->username_hash());
    684   return true;
    685 }
    686 
    687 WallpaperPrivateRestoreMinimizedWindowsFunction::
    688     WallpaperPrivateRestoreMinimizedWindowsFunction() {
    689 }
    690 
    691 WallpaperPrivateRestoreMinimizedWindowsFunction::
    692     ~WallpaperPrivateRestoreMinimizedWindowsFunction() {
    693 }
    694 
    695 bool WallpaperPrivateRestoreMinimizedWindowsFunction::RunAsync() {
    696   WindowStateManager::RestoreWindows(
    697       user_manager::UserManager::Get()->GetActiveUser()->username_hash());
    698   return true;
    699 }
    700 
    701 WallpaperPrivateGetThumbnailFunction::WallpaperPrivateGetThumbnailFunction() {
    702 }
    703 
    704 WallpaperPrivateGetThumbnailFunction::~WallpaperPrivateGetThumbnailFunction() {
    705 }
    706 
    707 bool WallpaperPrivateGetThumbnailFunction::RunAsync() {
    708   scoped_ptr<get_thumbnail::Params> params(
    709       get_thumbnail::Params::Create(*args_));
    710   EXTENSION_FUNCTION_VALIDATE(params);
    711 
    712   base::FilePath thumbnail_path;
    713   std::string email =
    714       user_manager::UserManager::Get()->GetActiveUser()->email();
    715   if (params->source == get_thumbnail::Params::SOURCE_ONLINE) {
    716     std::string file_name = GURL(params->url_or_file).ExtractFileName();
    717     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS,
    718                            &thumbnail_path));
    719     thumbnail_path = thumbnail_path.Append(file_name);
    720   } else {
    721     if (!IsOEMDefaultWallpaper()) {
    722       SetError("No OEM wallpaper.");
    723       SendResponse(false);
    724       return false;
    725     }
    726 
    727     // TODO(bshe): Small resolution wallpaper is used here as wallpaper
    728     // thumbnail. We should either resize it or include a wallpaper thumbnail in
    729     // addition to large and small wallpaper resolutions.
    730     thumbnail_path = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
    731         ash::switches::kAshDefaultWallpaperSmall);
    732   }
    733 
    734   sequence_token_ = BrowserThread::GetBlockingPool()->
    735       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    736   scoped_refptr<base::SequencedTaskRunner> task_runner =
    737       BrowserThread::GetBlockingPool()->
    738           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    739               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
    740 
    741   task_runner->PostTask(FROM_HERE,
    742       base::Bind(&WallpaperPrivateGetThumbnailFunction::Get, this,
    743                  thumbnail_path));
    744   return true;
    745 }
    746 
    747 void WallpaperPrivateGetThumbnailFunction::Failure(
    748     const std::string& file_name) {
    749   SetError(base::StringPrintf("Failed to access wallpaper thumbnails for %s.",
    750                               file_name.c_str()));
    751   SendResponse(false);
    752 }
    753 
    754 void WallpaperPrivateGetThumbnailFunction::FileNotLoaded() {
    755   SendResponse(true);
    756 }
    757 
    758 void WallpaperPrivateGetThumbnailFunction::FileLoaded(
    759     const std::string& data) {
    760   BinaryValue* thumbnail = BinaryValue::CreateWithCopiedBuffer(data.c_str(),
    761                                                                data.size());
    762   SetResult(thumbnail);
    763   SendResponse(true);
    764 }
    765 
    766 void WallpaperPrivateGetThumbnailFunction::Get(const base::FilePath& path) {
    767   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    768       sequence_token_));
    769   std::string data;
    770   if (GetData(path, &data)) {
    771     if (data.empty()) {
    772       BrowserThread::PostTask(
    773         BrowserThread::UI, FROM_HERE,
    774         base::Bind(&WallpaperPrivateGetThumbnailFunction::FileNotLoaded, this));
    775     } else {
    776       BrowserThread::PostTask(
    777         BrowserThread::UI, FROM_HERE,
    778         base::Bind(&WallpaperPrivateGetThumbnailFunction::FileLoaded, this,
    779                    data));
    780     }
    781   } else {
    782     BrowserThread::PostTask(
    783         BrowserThread::UI, FROM_HERE,
    784         base::Bind(&WallpaperPrivateGetThumbnailFunction::Failure, this,
    785                    path.BaseName().value()));
    786   }
    787 }
    788 
    789 WallpaperPrivateSaveThumbnailFunction::WallpaperPrivateSaveThumbnailFunction() {
    790 }
    791 
    792 WallpaperPrivateSaveThumbnailFunction::
    793     ~WallpaperPrivateSaveThumbnailFunction() {}
    794 
    795 bool WallpaperPrivateSaveThumbnailFunction::RunAsync() {
    796   scoped_ptr<save_thumbnail::Params> params(
    797       save_thumbnail::Params::Create(*args_));
    798   EXTENSION_FUNCTION_VALIDATE(params);
    799 
    800   sequence_token_ = BrowserThread::GetBlockingPool()->
    801       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    802   scoped_refptr<base::SequencedTaskRunner> task_runner =
    803       BrowserThread::GetBlockingPool()->
    804           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    805               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
    806 
    807   task_runner->PostTask(FROM_HERE,
    808       base::Bind(&WallpaperPrivateSaveThumbnailFunction::Save,
    809                  this, params->data, GURL(params->url).ExtractFileName()));
    810   return true;
    811 }
    812 
    813 void WallpaperPrivateSaveThumbnailFunction::Failure(
    814     const std::string& file_name) {
    815   SetError(base::StringPrintf("Failed to create/write thumbnail of %s.",
    816                               file_name.c_str()));
    817   SendResponse(false);
    818 }
    819 
    820 void WallpaperPrivateSaveThumbnailFunction::Success() {
    821   SendResponse(true);
    822 }
    823 
    824 void WallpaperPrivateSaveThumbnailFunction::Save(const std::string& data,
    825                                           const std::string& file_name) {
    826   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    827       sequence_token_));
    828   if (SaveData(chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS, file_name, data)) {
    829     BrowserThread::PostTask(
    830       BrowserThread::UI, FROM_HERE,
    831       base::Bind(&WallpaperPrivateSaveThumbnailFunction::Success, this));
    832   } else {
    833     BrowserThread::PostTask(
    834           BrowserThread::UI, FROM_HERE,
    835           base::Bind(&WallpaperPrivateSaveThumbnailFunction::Failure,
    836                      this, file_name));
    837   }
    838 }
    839 
    840 WallpaperPrivateGetOfflineWallpaperListFunction::
    841     WallpaperPrivateGetOfflineWallpaperListFunction() {
    842 }
    843 
    844 WallpaperPrivateGetOfflineWallpaperListFunction::
    845     ~WallpaperPrivateGetOfflineWallpaperListFunction() {
    846 }
    847 
    848 bool WallpaperPrivateGetOfflineWallpaperListFunction::RunAsync() {
    849   sequence_token_ = BrowserThread::GetBlockingPool()->
    850       GetNamedSequenceToken(chromeos::kWallpaperSequenceTokenName);
    851   scoped_refptr<base::SequencedTaskRunner> task_runner =
    852       BrowserThread::GetBlockingPool()->
    853           GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
    854               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
    855 
    856   task_runner->PostTask(FROM_HERE,
    857       base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::GetList,
    858                  this));
    859   return true;
    860 }
    861 
    862 void WallpaperPrivateGetOfflineWallpaperListFunction::GetList() {
    863   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
    864       sequence_token_));
    865   std::vector<std::string> file_list;
    866   base::FilePath wallpaper_dir;
    867   CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
    868   if (base::DirectoryExists(wallpaper_dir)) {
    869     base::FileEnumerator files(wallpaper_dir, false,
    870                                base::FileEnumerator::FILES);
    871     for (base::FilePath current = files.Next(); !current.empty();
    872          current = files.Next()) {
    873       std::string file_name = current.BaseName().RemoveExtension().value();
    874       // Do not add file name of small resolution wallpaper to the list.
    875       if (!EndsWith(file_name, chromeos::kSmallWallpaperSuffix, true))
    876         file_list.push_back(current.BaseName().value());
    877     }
    878   }
    879   BrowserThread::PostTask(
    880       BrowserThread::UI, FROM_HERE,
    881       base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete,
    882                  this, file_list));
    883 }
    884 
    885 void WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete(
    886     const std::vector<std::string>& file_list) {
    887   base::ListValue* results = new base::ListValue();
    888   results->AppendStrings(file_list);
    889   SetResult(results);
    890   SendResponse(true);
    891 }
    892