Rename ash desktop_background to wallpaper.

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 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/users/wallpaper/wallpaper_manager.h"
 
 #include <stdint.h>
 #include <numeric>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
-#include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/public/interfaces/wallpaper.mojom.h"
 #include "ash/shell.h"
+#include "ash/wallpaper/wallpaper_controller.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
@@ skipping 75 matching lines @@
   const base::FilePath default_downloaded_file_name =
       ServicesCustomizationDocument::GetCustomizedWallpaperDownloadedFileName();
   const base::FilePath default_cache_dir =
       ServicesCustomizationDocument::GetCustomizedWallpaperCacheDir();
   if (default_downloaded_file_name.empty() || default_cache_dir.empty())
     return base::FilePath();
   return default_cache_dir.Append(
       default_downloaded_file_name.BaseName().value() + suffix);
 }
 
-// Whether DesktopBackgroundController should start with customized default
+// Whether WallpaperController should start with customized default
 // wallpaper in WallpaperManager::InitializeWallpaper() or not.
 bool ShouldUseCustomizedDefaultWallpaper() {
   PrefService* pref_service = g_browser_process->local_state();
 
   return !(pref_service->FindPreference(
       prefs::kCustomizationDefaultWallpaperURL)->IsDefaultValue());
 }
 
 // Returns index of the first public session user found in |users|
 // or -1 otherwise.
@@ skipping 91 matching lines @@
     shell::Connector* connector =
         content::MojoShellConnection::GetForProcess()->GetConnector();
     ash::mojom::WallpaperControllerPtr wallpaper_controller;
     connector->ConnectToInterface("mojo:ash", &wallpaper_controller);
     wallpaper_controller->SetWallpaper(*image.bitmap(),
                                        WallpaperLayoutToMojo(layout));
     return;
   }
   // Avoid loading unnecessary wallpapers in tests without a shell instance.
   if (ash::Shell::HasInstance()) {
-    ash::Shell::GetInstance()
-        ->desktop_background_controller()
-        ->SetWallpaperImage(image, layout);
+    ash::Shell::GetInstance()->wallpaper_controller()->SetWallpaperImage(
+        image, layout);
   }
 }
 
 }  // namespace
 
 // This is "wallpaper either scheduled to load, or loading right now".
 //
 // While enqueued, it defines moment in the future, when it will be loaded.
 // Enqueued but not started request might be updated by subsequent load
 // request. Therefore it's created empty, and updated being enqueued.
@@ skipping 161 matching lines @@
 // static
 void WallpaperManager::Shutdown() {
   CHECK(wallpaper_manager);
   delete wallpaper_manager;
   wallpaper_manager = nullptr;
 }
 
 WallpaperManager::WallpaperResolution
 WallpaperManager::GetAppropriateResolution() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  gfx::Size size =
-      ash::DesktopBackgroundController::GetMaxDisplaySizeInNative();
+  gfx::Size size = ash::WallpaperController::GetMaxDisplaySizeInNative();
   return (size.width() > wallpaper::kSmallWallpaperMaxWidth ||
           size.height() > wallpaper::kSmallWallpaperMaxHeight)
              ? WALLPAPER_RESOLUTION_LARGE
              : WALLPAPER_RESOLUTION_SMALL;
 }
 
 void WallpaperManager::AddObservers() {
   show_user_name_on_signin_subscription_ =
       CrosSettings::Get()->AddSettingsObserver(
           kAccountsPrefShowUserNamesOnSignIn,
@@ skipping 40 matching lines @@
     // used here to determine if current user is guest.
     return;
   }
 
   if (command_line->HasSwitch(::switches::kTestType))
     WizardController::SetZeroDelays();
 
   // Zero delays is also set in autotests.
   if (WizardController::IsZeroDelayEnabled()) {
     // Ensure tests have some sort of wallpaper.
-    ash::Shell::GetInstance()->desktop_background_controller()->
-        CreateEmptyWallpaper();
+    ash::Shell::GetInstance()->wallpaper_controller()->CreateEmptyWallpaper();
     return;
   }
 
   if (!user_manager->IsUserLoggedIn()) {
     if (!StartupUtils::IsDeviceRegistered())
       SetDefaultWallpaperDelayed(login::SignInAccountId());
     else
       InitializeRegisteredDeviceWallpaper();
     return;
   }
@@ skipping 77 matching lines @@
 void WallpaperManager::SetCustomWallpaper(
     const AccountId& account_id,
     const wallpaper::WallpaperFilesId& wallpaper_files_id,
     const std::string& file,
     wallpaper::WallpaperLayout layout,
     user_manager::User::WallpaperType type,
     const gfx::ImageSkia& image,
     bool update_wallpaper) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  // There is no visible background in kiosk mode.
+  // There is no visible wallpaper in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
   if (type != user_manager::User::POLICY && IsPolicyControlled(account_id))
     return;
 
   base::FilePath wallpaper_path = GetCustomWallpaperPath(
       wallpaper::kOriginalWallpaperSubDir, wallpaper_files_id, file);
 
@@ skipping 59 matching lines @@
   GetPendingWallpaper(account_id, false)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::SetDefaultWallpaperDelayed(const AccountId& account_id) {
   GetPendingWallpaper(account_id, true)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::DoSetDefaultWallpaper(
     const AccountId& account_id,
     MovableOnDestroyCallbackHolder on_finish) {
-  // There is no visible background in kiosk mode.
+  // There is no visible wallpaper in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   wallpaper_cache_.erase(account_id);
 
   WallpaperResolution resolution = GetAppropriateResolution();
   const bool use_small = (resolution == WALLPAPER_RESOLUTION_SMALL);
 
   const base::FilePath* file = NULL;
 
   const user_manager::User* user =
@@ skipping 60 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Some unit tests come here without a UserManager or without a pref system.
   if (!user_manager::UserManager::IsInitialized() ||
       !g_browser_process->local_state()) {
     return;
   }
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
 
-  // User is unknown or there is no visible background in kiosk mode.
+  // User is unknown or there is no visible wallpaper in kiosk mode.
   if (!user || user->GetType() == user_manager::USER_TYPE_KIOSK_APP)
     return;
 
   // Guest user or regular user in ephemeral mode.
   if ((user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
            account_id) &&
        user->HasGaiaAccount()) ||
       user->GetType() == user_manager::USER_TYPE_GUEST) {
     InitInitialUserWallpaper(account_id, false);
     GetPendingWallpaper(account_id, delayed)->ResetSetDefaultWallpaper();
@@ skipping 59 matching lines @@
   }
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(
     const AccountId& account_id,
     const gfx::ImageSkia& image,
     wallpaper::WallpaperLayout layout,
     bool update_wallpaper) {
   DCHECK(user_manager::UserManager::Get()->IsUserLoggedIn());
 
-  // There is no visible background in kiosk mode.
+  // There is no visible wallpaper in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   WallpaperInfo info;
   info.layout = layout;
 
   // This is an API call and we do not know the path. So we set the image, but
   // no path.
   wallpaper_cache_[account_id] =
       CustomWallpaperElement(base::FilePath(), image);
 
@@ skipping 316 matching lines @@
 }
 
 void WallpaperManager::SetDefaultWallpaperPath(
     const base::FilePath& default_small_wallpaper_file,
     std::unique_ptr<gfx::ImageSkia> small_wallpaper_image,
     const base::FilePath& default_large_wallpaper_file,
     std::unique_ptr<gfx::ImageSkia> large_wallpaper_image) {
   default_small_wallpaper_file_ = default_small_wallpaper_file;
   default_large_wallpaper_file_ = default_large_wallpaper_file;
 
-  ash::DesktopBackgroundController* dbc =
-      ash::Shell::GetInstance()->desktop_background_controller();
+  ash::WallpaperController* controller =
+      ash::Shell::GetInstance()->wallpaper_controller();
 
   // |need_update_screen| is true if the previous default wallpaper is visible
   // now, so we need to update wallpaper on the screen.
   //
   // Layout is ignored here, so wallpaper::WALLPAPER_LAYOUT_CENTER is used
   // as a placeholder only.
   const bool need_update_screen =
       default_wallpaper_image_.get() &&
-      dbc->WallpaperIsAlreadyLoaded(default_wallpaper_image_->image(),
-                                    false /* compare_layouts */,
-                                    wallpaper::WALLPAPER_LAYOUT_CENTER);
+      controller->WallpaperIsAlreadyLoaded(default_wallpaper_image_->image(),
+                                           false /* compare_layouts */,
+                                           wallpaper::WALLPAPER_LAYOUT_CENTER);
 
   default_wallpaper_image_.reset();
   if (GetAppropriateResolution() == WALLPAPER_RESOLUTION_SMALL) {
     if (small_wallpaper_image) {
       default_wallpaper_image_.reset(
           new user_manager::UserImage(*small_wallpaper_image));
       default_wallpaper_image_->set_file_path(default_small_wallpaper_file);
     }
   } else {
     if (large_wallpaper_image) {
       default_wallpaper_image_.reset(
           new user_manager::UserImage(*large_wallpaper_image));
       default_wallpaper_image_->set_file_path(default_large_wallpaper_file);
     }
   }
 
-  if (need_update_screen) {
+  if (need_update_screen)
     DoSetDefaultWallpaper(EmptyAccountId(), MovableOnDestroyCallbackHolder());
-  }
 }
 
 wallpaper::WallpaperFilesId WallpaperManager::GetFilesId(
     const AccountId& account_id) const {
   std::string stored_value;
   if (user_manager::known_user::GetStringPref(account_id, kWallpaperFilesId,
                                               &stored_value)) {
     return wallpaper::WallpaperFilesId::FromString(stored_value);
   }
   const std::string& old_id = account_id.GetUserEmail();  // Migrated
   const wallpaper::WallpaperFilesId files_id = HashWallpaperFilesIdStr(old_id);
   SetKnownUserWallpaperFilesId(account_id, files_id);
   return files_id;
 }
 
 }  // namespace chromeos