chrome/browser/chromeos/extensions/wallpaper_private_api.cc

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