| // 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. |
| |
| #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_ |
| #define CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_ |
| |
| #include <deque> |
| #include <string> |
| #include <vector> |
| |
| #include "ash/desktop_background/desktop_background_controller.h" |
| #include "base/files/file_path.h" |
| #include "base/memory/ref_counted_memory.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/observer_list.h" |
| #include "base/threading/sequenced_worker_pool.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/chromeos/login/users/avatar/user_image_loader.h" |
| #include "chrome/browser/chromeos/settings/cros_settings.h" |
| #include "components/user_manager/user.h" |
| #include "components/user_manager/user_image/user_image.h" |
| #include "content/public/browser/notification_observer.h" |
| #include "content/public/browser/notification_registrar.h" |
| #include "third_party/icu/source/i18n/unicode/timezone.h" |
| #include "ui/gfx/image/image_skia.h" |
| |
| class PrefRegistrySimple; |
| |
| namespace base { |
| class CommandLine; |
| class SequencedTaskRunner; |
| } |
| |
| namespace user_manager { |
| class User; |
| class UserImage; |
| } |
| |
| namespace chromeos { |
| |
| struct WallpaperInfo { |
| // Either file name of migrated wallpaper including first directory level |
| // (corresponding to user id hash) or online wallpaper URL. |
| std::string location; |
| ash::WallpaperLayout layout; |
| user_manager::User::WallpaperType type; |
| base::Time date; |
| bool operator==(const WallpaperInfo& other) { |
| return (location == other.location) && (layout == other.layout) && |
| (type == other.type); |
| } |
| }; |
| |
| class MovableOnDestroyCallback; |
| typedef scoped_ptr<MovableOnDestroyCallback> MovableOnDestroyCallbackHolder; |
| |
| class WallpaperManagerBrowserTest; |
| |
| // Name of wallpaper sequence token. |
| extern const char kWallpaperSequenceTokenName[]; |
| |
| // File path suffices of resized small or large wallpaper. |
| // TODO(bshe): Use the same sub folder system as custom wallpapers use. |
| // crbug.com/174928 |
| extern const char kSmallWallpaperSuffix[]; |
| extern const char kLargeWallpaperSuffix[]; |
| |
| // Directory names of custom wallpapers. |
| extern const char kSmallWallpaperSubDir[]; |
| extern const char kLargeWallpaperSubDir[]; |
| extern const char kOriginalWallpaperSubDir[]; |
| extern const char kThumbnailWallpaperSubDir[]; |
| |
| // The width and height of small/large resolution wallpaper. When screen size is |
| // smaller than |kSmallWallpaperMaxWidth| and |kSmallWallpaperMaxHeight|, the |
| // small resolution wallpaper should be used. Otherwise, use the large |
| // resolution wallpaper. |
| extern const int kSmallWallpaperMaxWidth; |
| extern const int kSmallWallpaperMaxHeight; |
| extern const int kLargeWallpaperMaxWidth; |
| extern const int kLargeWallpaperMaxHeight; |
| |
| // The width and height of wallpaper thumbnails. |
| extern const int kWallpaperThumbnailWidth; |
| extern const int kWallpaperThumbnailHeight; |
| |
| // This singleton class maintains wallpapers for users who have logged into this |
| // Chrome OS device. |
| class WallpaperManager: public content::NotificationObserver { |
| public: |
| enum WallpaperResolution { |
| WALLPAPER_RESOLUTION_LARGE, |
| WALLPAPER_RESOLUTION_SMALL |
| }; |
| |
| // For testing. |
| class TestApi { |
| public: |
| explicit TestApi(WallpaperManager* wallpaper_manager); |
| virtual ~TestApi(); |
| |
| base::FilePath current_wallpaper_path(); |
| |
| bool GetWallpaperFromCache(const std::string& user_id, |
| gfx::ImageSkia* image); |
| |
| void SetWallpaperCache(const std::string& user_id, |
| const gfx::ImageSkia& image); |
| |
| void ClearDisposableWallpaperCache(); |
| |
| private: |
| WallpaperManager* wallpaper_manager_; // not owned |
| |
| DISALLOW_COPY_AND_ASSIGN(TestApi); |
| }; |
| |
| // This should be public to allow access from functions in anonymous |
| // namespace. |
| class CustomizedWallpaperRescaledFiles; |
| |
| class Observer { |
| public: |
| virtual ~Observer() {} |
| virtual void OnWallpaperAnimationFinished(const std::string& user_id) = 0; |
| virtual void OnUpdateWallpaperForTesting() {} |
| virtual void OnPendingListEmptyForTesting() {} |
| }; |
| |
| // 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. |
| // |
| // PendingWallpaper is owned by WallpaperManager, but reference to this object |
| // is passed to other threads by PostTask() calls, therefore it is |
| // RefCountedThreadSafe. |
| class PendingWallpaper : public base::RefCountedThreadSafe<PendingWallpaper> { |
| public: |
| // Do LoadWallpaper() - image not found in cache. |
| PendingWallpaper(const base::TimeDelta delay, const std::string& user_id); |
| |
| // There are 4 cases in SetUserWallpaper: |
| // 1) gfx::ImageSkia is found in cache. |
| // - Schedule task to (probably) resize it and install: |
| // call ash::Shell::GetInstance()->desktop_background_controller()-> |
| // SetCustomWallpaper(user_wallpaper, layout); |
| // 2) WallpaperInfo is found in cache |
| // - need to LoadWallpaper(), resize and install. |
| // 3) wallpaper path is not NULL, load image URL, then resize, etc... |
| // 4) SetDefaultWallpaper (either on some error, or when user is new). |
| void ResetSetWallpaperImage(const gfx::ImageSkia& image, |
| const WallpaperInfo& info); |
| void ResetLoadWallpaper(const WallpaperInfo& info); |
| void ResetSetCustomWallpaper(const WallpaperInfo& info, |
| const base::FilePath& wallpaper_path); |
| void ResetSetDefaultWallpaper(); |
| |
| private: |
| friend class base::RefCountedThreadSafe<PendingWallpaper>; |
| |
| ~PendingWallpaper(); |
| |
| // All Reset*() methods use SetMode() to set object to new state. |
| void SetMode(const gfx::ImageSkia& image, |
| const WallpaperInfo& info, |
| const base::FilePath& wallpaper_path, |
| const bool is_default); |
| |
| // This method is usually triggered by timer to actually load request. |
| void ProcessRequest(); |
| |
| // This method is called by callback, when load request is finished. |
| void OnWallpaperSet(); |
| |
| std::string user_id_; |
| WallpaperInfo info_; |
| gfx::ImageSkia user_wallpaper_; |
| base::FilePath wallpaper_path_; |
| |
| // Load default wallpaper instead of user image. |
| bool default_; |
| |
| // This is "on destroy" callback that will call OnWallpaperSet() when |
| // image will be loaded. |
| MovableOnDestroyCallbackHolder on_finish_; |
| base::OneShotTimer<WallpaperManager::PendingWallpaper> timer; |
| |
| // Load start time to calculate duration. |
| base::Time started_load_at_; |
| |
| DISALLOW_COPY_AND_ASSIGN(PendingWallpaper); |
| }; |
| |
| WallpaperManager(); |
| virtual ~WallpaperManager(); |
| |
| // Get pointer to singleton WallpaperManager instance, create it if necessary. |
| static WallpaperManager* Get(); |
| |
| // Registers wallpaper manager preferences. |
| static void RegisterPrefs(PrefRegistrySimple* registry); |
| |
| // Resizes |image| to a resolution which is nearest to |preferred_width| and |
| // |preferred_height| while respecting the |layout| choice. |output_skia| is |
| // optional (may be NULL). Returns true on success. |
| static bool ResizeImage(const gfx::ImageSkia& image, |
| ash::WallpaperLayout layout, |
| int preferred_width, |
| int preferred_height, |
| scoped_refptr<base::RefCountedBytes>* output, |
| gfx::ImageSkia* output_skia); |
| |
| // Resizes |image| to a resolution which is nearest to |preferred_width| and |
| // |preferred_height| while respecting the |layout| choice and saves the |
| // resized wallpaper to |path|. |output_skia| is optional (may be |
| // NULL). Returns true on success. |
| static bool ResizeAndSaveWallpaper(const gfx::ImageSkia& image, |
| const base::FilePath& path, |
| ash::WallpaperLayout layout, |
| int preferred_width, |
| int preferred_height, |
| gfx::ImageSkia* output_skia); |
| |
| // Returns the appropriate wallpaper resolution for all root windows. |
| static WallpaperResolution GetAppropriateResolution(); |
| |
| // Returns custom wallpaper path. Append |sub_dir|, |user_id_hash| and |file| |
| // to custom wallpaper directory. |
| static base::FilePath GetCustomWallpaperPath(const char* sub_dir, |
| const std::string& user_id_hash, |
| const std::string& file); |
| |
| void SetCommandLineForTesting(base::CommandLine* command_line); |
| |
| // Indicates imminent shutdown, allowing the WallpaperManager to remove any |
| // observers it has registered. |
| void Shutdown(); |
| |
| // Adds PowerManagerClient, TimeZoneSettings and CrosSettings observers. |
| void AddObservers(); |
| |
| // Loads wallpaper asynchronously if the current wallpaper is not the |
| // wallpaper of logged in user. |
| void EnsureLoggedInUserWallpaperLoaded(); |
| |
| // Gets wallpaper information of logged in user. |
| bool GetLoggedInUserWallpaperInfo(WallpaperInfo* info); |
| |
| // Initializes wallpaper. If logged in, loads user's wallpaper. If not logged |
| // in, uses a solid color wallpaper. If logged in as a stub user, uses an |
| // empty wallpaper. |
| void InitializeWallpaper(); |
| |
| // NotificationObserver overrides: |
| virtual void Observe(int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) override; |
| |
| // Removes all |user_id| related wallpaper info and saved wallpapers. |
| void RemoveUserWallpaperInfo(const std::string& user_id); |
| |
| // Calls SetCustomWallpaper() with |user_id_hash| received from cryptohome. |
| void SetCustomWallpaperOnSanitizedUsername(const std::string& user_id, |
| const gfx::ImageSkia& image, |
| bool update_wallpaper, |
| bool cryptohome_success, |
| const std::string& user_id_hash); |
| |
| // Saves custom wallpaper to file, post task to generate thumbnail and updates |
| // local state preferences. If |update_wallpaper| is false, don't change |
| // wallpaper but only update cache. |
| void SetCustomWallpaper(const std::string& user_id, |
| const std::string& user_id_hash, |
| const std::string& file, |
| ash::WallpaperLayout layout, |
| user_manager::User::WallpaperType type, |
| const gfx::ImageSkia& image, |
| bool update_wallpaper); |
| |
| // Use given files as new default wallpaper. |
| // Reloads current wallpaper, if old default was loaded. |
| // Current value of default_wallpaper_image_ is destroyed. |
| // Sets default_wallpaper_image_ either to |small_wallpaper_image| or |
| // |large_wallpaper_image| depending on GetAppropriateResolution(). |
| void SetDefaultWallpaperPath( |
| const base::FilePath& customized_default_wallpaper_file_small, |
| scoped_ptr<gfx::ImageSkia> small_wallpaper_image, |
| const base::FilePath& customized_default_wallpaper_file_large, |
| scoped_ptr<gfx::ImageSkia> large_wallpaper_image); |
| |
| // Sets wallpaper to default wallpaper (asynchronously with zero delay). |
| void SetDefaultWallpaperNow(const std::string& user_id); |
| |
| // Sets wallpaper to default wallpaper (asynchronously with default delay). |
| void SetDefaultWallpaperDelayed(const std::string& user_id); |
| |
| // Sets selected wallpaper information for |user_id| and saves it to Local |
| // State if |is_persistent| is true. |
| void SetUserWallpaperInfo(const std::string& user_id, |
| const WallpaperInfo& info, |
| bool is_persistent); |
| |
| // Sets |user_id|'s wallpaper (asynchronously with zero delay). |
| void SetUserWallpaperNow(const std::string& user_id); |
| |
| // Sets |user_id|'s wallpaper (asynchronously with default delay). |
| void SetUserWallpaperDelayed(const std::string& user_id); |
| |
| // Sets wallpaper to |image| (asynchronously with zero delay). If |
| // |update_wallpaper| is false, skip change wallpaper but only update cache. |
| void SetWallpaperFromImageSkia(const std::string& user_id, |
| const gfx::ImageSkia& image, |
| ash::WallpaperLayout layout, |
| bool update_wallpaper); |
| |
| // Updates current wallpaper. It may switch the size of wallpaper based on the |
| // current display's resolution. (asynchronously with zero delay) |
| void UpdateWallpaper(bool clear_cache); |
| |
| // Adds given observer to the list. |
| void AddObserver(Observer* observer); |
| |
| // Removes given observer from the list. |
| void RemoveObserver(Observer* observer); |
| |
| // Returns whether a wallpaper policy is enforced for |user_id|. |
| bool IsPolicyControlled(const std::string& user_id) const; |
| |
| // Called when a wallpaper policy has been set for |user_id|. Blocks user |
| // from changing the wallpaper. |
| void OnPolicySet(const std::string& policy, const std::string& user_id); |
| |
| // Called when the wallpaper policy has been cleared for |user_id|. |
| void OnPolicyCleared(const std::string& policy, const std::string& user_id); |
| |
| // Called when the policy-set wallpaper has been fetched. Initiates decoding |
| // of the JPEG |data| with a callback to SetPolicyControlledWallpaper(). |
| void OnPolicyFetched(const std::string& policy, |
| const std::string& user_id, |
| scoped_ptr<std::string> data); |
| |
| // This is called from CustomizationDocument. |
| // |resized_directory| is the directory where resized versions are stored and |
| // must be writable. |
| void SetCustomizedDefaultWallpaper(const GURL& wallpaper_url, |
| const base::FilePath& downloaded_file, |
| const base::FilePath& resized_directory); |
| |
| // Returns queue size. |
| size_t GetPendingListSizeForTesting() const; |
| |
| private: |
| friend class TestApi; |
| friend class PendingWallpaper; |
| friend class WallpaperManagerBrowserTest; |
| friend class WallpaperManagerBrowserTestDefaultWallpaper; |
| friend class WallpaperManagerPolicyTest; |
| |
| typedef std::map<std::string, gfx::ImageSkia> CustomWallpaperMap; |
| |
| |
| // Saves original custom wallpaper to |path| (absolute path) on filesystem |
| // and starts resizing operation of the custom wallpaper if necessary. |
| static void SaveCustomWallpaper(const std::string& user_id_hash, |
| const base::FilePath& path, |
| ash::WallpaperLayout layout, |
| scoped_ptr<gfx::ImageSkia> image); |
| |
| // Moves custom wallpapers from |user_id| directory to |user_id_hash| |
| // directory. |
| static void MoveCustomWallpapersOnWorker( |
| const std::string& user_id, |
| const std::string& user_id_hash, |
| base::WeakPtr<WallpaperManager> weak_ptr); |
| |
| // Gets |user_id|'s custom wallpaper at |wallpaper_path|. Falls back on |
| // original custom wallpaper. When |update_wallpaper| is true, sets wallpaper |
| // to the loaded wallpaper. Must run on wallpaper sequenced worker thread. |
| static void GetCustomWallpaperInternal( |
| const std::string& user_id, |
| const WallpaperInfo& info, |
| const base::FilePath& wallpaper_path, |
| bool update_wallpaper, |
| MovableOnDestroyCallbackHolder on_finish, |
| base::WeakPtr<WallpaperManager> weak_ptr); |
| |
| // Resize and save customized default wallpaper. |
| static void ResizeCustomizedDefaultWallpaper( |
| scoped_ptr<gfx::ImageSkia> image, |
| const user_manager::UserImage::RawImage& raw_image, |
| const CustomizedWallpaperRescaledFiles* rescaled_files, |
| bool* success, |
| gfx::ImageSkia* small_wallpaper_image, |
| gfx::ImageSkia* large_wallpaper_image); |
| |
| // Initialize wallpaper for the specified user to default and saves this |
| // settings in local state. |
| void InitInitialUserWallpaper(const std::string& user_id, bool is_persistent); |
| |
| // Set wallpaper to |user_image| controlled by policy. (Takes a UserImage |
| // because that's the callback interface provided by UserImageLoader.) |
| void SetPolicyControlledWallpaper(const std::string& user_id, |
| const user_manager::UserImage& user_image); |
| |
| // Gets encoded wallpaper from cache. Returns true if success. |
| bool GetWallpaperFromCache(const std::string& user_id, gfx::ImageSkia* image); |
| |
| // The number of wallpapers have loaded. For test only. |
| int loaded_wallpapers() const { return loaded_wallpapers_; } |
| |
| // Cache some (or all) logged in users' wallpapers to memory at login |
| // screen. It should not compete with first wallpaper loading when boot |
| // up/initialize login WebUI page. |
| // There are two ways the first wallpaper might be loaded: |
| // 1. Loaded on boot. Login WebUI waits for it. |
| // 2. When flag --disable-boot-animation is passed. Login WebUI is loaded |
| // right away and in 500ms after. Wallpaper started to load. |
| // For case 2, should_cache_wallpaper_ is used to indicate if we need to |
| // cache wallpapers on wallpaper animation finished. The cache operation |
| // should be only executed once. |
| void CacheUsersWallpapers(); |
| |
| // Caches |user_id|'s wallpaper to memory. |
| void CacheUserWallpaper(const std::string& user_id); |
| |
| // Clears disposable ONLINE and CUSTOM wallpaper cache. At multi profile |
| // world, logged in users' wallpaper cache is not disposable. |
| void ClearDisposableWallpaperCache(); |
| |
| // Clears all obsolete wallpaper prefs from old version wallpaper pickers. |
| void ClearObsoleteWallpaperPrefs(); |
| |
| // Deletes all |user_id| related custom wallpapers and directories. |
| void DeleteUserWallpapers(const std::string& user_id, |
| const std::string& path_to_file); |
| |
| // Gets the CommandLine representing the current process's command line. |
| base::CommandLine* GetCommandLine(); |
| |
| // Initialize wallpaper of registered device after device policy is trusted. |
| // Note that before device is enrolled, it proceeds with untrusted setting. |
| void InitializeRegisteredDeviceWallpaper(); |
| |
| // Loads |user_id|'s wallpaper. When |update_wallpaper| is true, sets |
| // wallpaper to the loaded wallpaper. |
| void LoadWallpaper(const std::string& user_id, |
| const WallpaperInfo& info, |
| bool update_wallpaper, |
| MovableOnDestroyCallbackHolder on_finish); |
| |
| // Called when the original custom wallpaper is moved to the new place. |
| // Updates the corresponding user wallpaper info. |
| void MoveCustomWallpapersSuccess(const std::string& user_id, |
| const std::string& user_id_hash); |
| |
| // Moves custom wallpaper to a new place. Email address was used as directory |
| // name in the old system, this is not safe. New directory system uses |
| // user_id_hash instead of user_id. This must be called after user_id_hash is |
| // ready. |
| void MoveLoggedInUserCustomWallpaper(); |
| |
| // Gets wallpaper information of |user_id| from Local State or memory. Returns |
| // false if wallpaper information is not found. |
| bool GetUserWallpaperInfo(const std::string& user_id, |
| WallpaperInfo* info) const; |
| |
| // Sets wallpaper to the decoded wallpaper if |update_wallpaper| is true. |
| // Otherwise, cache wallpaper to memory if not logged in. (Takes a UserImage |
| // because that's the callback interface provided by UserImageLoader.) |
| void OnWallpaperDecoded(const std::string& user_id, |
| ash::WallpaperLayout layout, |
| bool update_wallpaper, |
| MovableOnDestroyCallbackHolder on_finish, |
| const user_manager::UserImage& user_image); |
| |
| // Creates new PendingWallpaper request (or updates currently pending). |
| void ScheduleSetUserWallpaper(const std::string& user_id, bool delayed); |
| |
| // Sets wallpaper to default. |
| void DoSetDefaultWallpaper( |
| const std::string& user_id, |
| MovableOnDestroyCallbackHolder on_finish); |
| |
| // Starts to load wallpaper at |wallpaper_path|. If |wallpaper_path| is the |
| // same as |current_wallpaper_path_|, do nothing. Must be called on UI thread. |
| void StartLoad(const std::string& user_id, |
| const WallpaperInfo& info, |
| bool update_wallpaper, |
| const base::FilePath& wallpaper_path, |
| MovableOnDestroyCallbackHolder on_finish); |
| |
| // After completed load operation, update average load time. |
| void SaveLastLoadTime(const base::TimeDelta elapsed); |
| |
| // Notify all registered observers. |
| void NotifyAnimationFinished(); |
| |
| // Returns modifiable PendingWallpaper. |
| // Returns pending_inactive_ or creates new PendingWallpaper if necessary. |
| PendingWallpaper* GetPendingWallpaper(const std::string& user_id, |
| bool delayed); |
| |
| // This is called by PendingWallpaper when load is finished. |
| void RemovePendingWallpaperFromList(PendingWallpaper* pending); |
| |
| // Calculate delay for next wallpaper load. |
| // It is usually average wallpaper load time. |
| // If last wallpaper load happened long ago, timeout should be reduced by |
| // the time passed after last wallpaper load. So usual user experience results |
| // in zero delay. |
| base::TimeDelta GetWallpaperLoadDelay() const; |
| |
| // This is called after we check that supplied default wallpaper files exist. |
| void SetCustomizedDefaultWallpaperAfterCheck( |
| const GURL& wallpaper_url, |
| const base::FilePath& downloaded_file, |
| scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files); |
| |
| // Starts rescaling of customized wallpaper. |
| void OnCustomizedDefaultWallpaperDecoded( |
| const GURL& wallpaper_url, |
| scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files, |
| const user_manager::UserImage& user_image); |
| |
| // Check the result of ResizeCustomizedDefaultWallpaper and finally |
| // apply Customized Default Wallpaper. |
| void OnCustomizedDefaultWallpaperResized( |
| const GURL& wallpaper_url, |
| scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files, |
| scoped_ptr<bool> success, |
| scoped_ptr<gfx::ImageSkia> small_wallpaper_image, |
| scoped_ptr<gfx::ImageSkia> large_wallpaper_image); |
| |
| // Init |*default_*_wallpaper_file_| from given command line and |
| // clear |default_wallpaper_image_|. |
| void SetDefaultWallpaperPathsFromCommandLine(base::CommandLine* command_line); |
| |
| // Sets wallpaper to decoded default. |
| void OnDefaultWallpaperDecoded(const base::FilePath& path, |
| const ash::WallpaperLayout layout, |
| scoped_ptr<user_manager::UserImage>* result, |
| MovableOnDestroyCallbackHolder on_finish, |
| const user_manager::UserImage& user_image); |
| |
| // Start decoding given default wallpaper. |
| void StartLoadAndSetDefaultWallpaper( |
| const base::FilePath& path, |
| const ash::WallpaperLayout layout, |
| MovableOnDestroyCallbackHolder on_finish, |
| scoped_ptr<user_manager::UserImage>* result_out); |
| |
| // Returns wallpaper subdirectory name for current resolution. |
| const char* GetCustomWallpaperSubdirForCurrentResolution(); |
| |
| // Init default_wallpaper_image_ with 1x1 image of default color. |
| void CreateSolidDefaultWallpaper(); |
| |
| // The number of loaded wallpapers. |
| int loaded_wallpapers_; |
| |
| // Sequence token associated with wallpaper operations. |
| base::SequencedWorkerPool::SequenceToken sequence_token_; |
| |
| // Wallpaper sequenced task runner. |
| scoped_refptr<base::SequencedTaskRunner> task_runner_; |
| |
| // The file path of current loaded/loading custom/online wallpaper. |
| base::FilePath current_wallpaper_path_; |
| |
| // Loads user wallpaper from its file. |
| scoped_refptr<UserImageLoader> wallpaper_loader_; |
| |
| // Logged-in user wallpaper information. |
| WallpaperInfo current_user_wallpaper_info_; |
| |
| // If non-NULL, used in place of the real command line. |
| base::CommandLine* command_line_for_testing_; |
| |
| // Caches wallpapers of users. Accessed only on UI thread. |
| CustomWallpaperMap wallpaper_cache_; |
| |
| // The last selected user on user pod row. |
| std::string last_selected_user_; |
| |
| bool should_cache_wallpaper_; |
| |
| scoped_ptr<CrosSettings::ObserverSubscription> |
| show_user_name_on_signin_subscription_; |
| |
| content::NotificationRegistrar registrar_; |
| |
| ObserverList<Observer> observers_; |
| |
| // These members are for the scheduler: |
| |
| // When last load attempt finished. |
| base::Time last_load_finished_at_; |
| |
| // last N wallpaper loads times. |
| std::deque<base::TimeDelta> last_load_times_; |
| |
| // Pointer to last inactive (waiting) entry of 'loading_' list. |
| // NULL when there is no inactive request. |
| PendingWallpaper* pending_inactive_; |
| |
| // Owns PendingWallpaper. |
| // PendingWallpaper deletes itself from here on load complete. |
| // All pending will be finally deleted on destroy. |
| typedef std::vector<scoped_refptr<PendingWallpaper> > PendingList; |
| PendingList loading_; |
| |
| base::FilePath default_small_wallpaper_file_; |
| base::FilePath default_large_wallpaper_file_; |
| |
| base::FilePath guest_small_wallpaper_file_; |
| base::FilePath guest_large_wallpaper_file_; |
| |
| // Current decoded default image is stored in cache. |
| scoped_ptr<user_manager::UserImage> default_wallpaper_image_; |
| |
| base::WeakPtrFactory<WallpaperManager> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(WallpaperManager); |
| }; |
| |
| } // namespace chromeos |
| |
| #endif // CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_ |