Move all wallpaper file loading and decoding from DesktopBackgroundController to WallpaperManager.

chrome/browser/chromeos/login/wallpaper_manager.h

 // Copyright (c) 2013 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_WALLPAPER_MANAGER_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_WALLPAPER_MANAGER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 50 matching lines @@
 // 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 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);
   };
 
   class Observer {
    public:
     virtual ~Observer() {}
     virtual void OnWallpaperAnimationFinished(const std::string& user_id) = 0;
+    virtual void OnUpdateWallpaperForTesting();

[oshima, 2014/04/07 17:16:11]

you may inline void empty method. (see ui/aura/window_observer.h for exmaple)

[Alexander Alekseev, 2014/04/08 13:18:49]

Done.

   };
 
   // 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
@@ skipping 53 matching lines @@
     base::Time started_load_at_;
 
     DISALLOW_COPY_AND_ASSIGN(PendingWallpaper);
   };
 
   static WallpaperManager* Get();
 
   WallpaperManager();
   virtual ~WallpaperManager();
 
-  void set_command_line_for_testing(base::CommandLine* command_line) {
-    command_line_for_testing_ = command_line;
-  }
+  void set_command_line_for_testing(base::CommandLine* command_line);

[oshima, 2014/04/07 17:16:11]

SetCommandLineForTesting if it's not inlined

[Alexander Alekseev, 2014/04/08 13:18:49]

Done.

 
   // Indicates imminent shutdown, allowing the WallpaperManager to remove any
   // observers it has registered.
   void Shutdown();
 
   // Registers wallpaper manager preferences.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Adds PowerManagerClient, TimeZoneSettings and CrosSettings observers.
   void AddObservers();
@@ skipping 30 matching lines @@
 
   // Removes all |user_id| related wallpaper info and saved wallpapers.
   void RemoveUserWallpaperInfo(const std::string& user_id);
 
   // Resizes |wallpaper| to a resolution which is nearest to |preferred_width|
   // and |preferred_height| while maintaining aspect ratio.
   bool ResizeWallpaper(const UserImage& wallpaper,
                        ash::WallpaperLayout layout,
                        int preferred_width,
                        int preferred_height,
-                       scoped_refptr<base::RefCountedBytes>* output) const;
+                       scoped_refptr<base::RefCountedBytes>* output,
+                       gfx::ImageSkia* output_skia) const;
 
   // Resizes |wallpaper| to a resolution which is nearest to |preferred_width|
   // and |preferred_height| while maintaining aspect ratio. And saves the
-  // resized wallpaper to |path|.
-  void ResizeAndSaveWallpaper(const UserImage& wallpaper,
+  // resized wallpaper to |path|. |result| is optional (may be NULL).
+  // Returns true on success.
+  bool ResizeAndSaveWallpaper(const UserImage& wallpaper,
                               const base::FilePath& path,
                               ash::WallpaperLayout layout,
                               int preferred_width,
-                              int preferred_height) const;
+                              int preferred_height,
+                              gfx::ImageSkia* result) const;

[oshima, 2014/04/07 17:16:11]

result_out

[Alexander Alekseev, 2014/04/08 13:18:49]

Done.

 
   // 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::WallpaperType type,
                           const UserImage& wallpaper,
@@ skipping 51 matching lines @@
 
   // 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);
 
+  // Returns the appropriate wallpaper resolution for all root windows.
+  static WallpaperResolution GetAppropriateResolution();
+
  private:
   friend class TestApi;
   friend class WallpaperManagerBrowserTest;
+  friend class WallpaperManagerBrowserTestDefaultWallpaper;
   friend class WallpaperManagerPolicyTest;
 
   typedef std::map<std::string, gfx::ImageSkia> CustomWallpaperMap;
 
   // Set |wallpaper| controlled by policy.
   void SetPolicyControlledWallpaper(const std::string& user_id,
                                     const UserImage& wallpaper);
 
   // Gets encoded wallpaper from cache. Returns true if success.
   bool GetWallpaperFromCache(const std::string& user_id,
@@ skipping 28 matching lines @@
 
   // Deletes all |user_id| related custom wallpapers and directories.
   void DeleteUserWallpapers(const std::string& user_id,
                             const std::string& path_to_file);
 
   // Creates all new custom wallpaper directories for |user_id_hash| if not
   // exist.
   void EnsureCustomWallpaperDirectories(const std::string& user_id_hash);
 
   // Gets the CommandLine representing the current process's command line.
-  base::CommandLine* GetComandLine();
+  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,
@@ skipping 50 matching lines @@
   void RecordUma(User::WallpaperType type, int index) const;
 
   // Saves original custom wallpaper to |path| (absolute path) on filesystem
   // and starts resizing operation of the custom wallpaper if necessary.
   void SaveCustomWallpaper(const std::string& user_id_hash,
                            const base::FilePath& path,
                            ash::WallpaperLayout layout,
                            const UserImage& wallpaper);
 
   // Saves wallpaper image raw |data| to |path| (absolute path) in file system.
-  void SaveWallpaperInternal(const base::FilePath& path, const char* data,
+  // True on success.
+  bool SaveWallpaperInternal(const base::FilePath& path,
+                             const char* data,
                              int size) const;
 
   // 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);
 
@@ skipping 16 matching lines @@
   PendingWallpaper* GetPendingWallpaper(const std::string& user_id,
                                         bool delayed);
 
   // 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;
 
+  // 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,
+                                 scoped_ptr<UserImage>* result,
+                                 MovableOnDestroyCallbackHolder on_finish,
+                                 const UserImage& wallpaper);
+
+  // Start decoding given default wallpaper.
+  void StartLoadAndSetDefaultWallpaper(
+      const base::FilePath& path,
+      scoped_ptr<UserImage>* result,

[oshima, 2014/04/07 17:16:11]

Looks like |result| output parameter? If so, move this after on_finish and
rename to result_out.

[Alexander Alekseev, 2014/04/08 13:18:49]

Done.

+      MovableOnDestroyCallbackHolder on_finish);
+
+  // Returns wallpaper subdirectory name for current resolution.
+  const char* GetCustomWallpaperSubdirForCurrentResolution();
+
   // 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.
@@ skipping 36 matching lines @@
   // 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<UserImage> default_wallpaper_image_;
+
   DISALLOW_COPY_AND_ASSIGN(WallpaperManager);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_WALLPAPER_MANAGER_H_