Apply default wallpaper from customization manifest.

chrome/browser/chromeos/customization_document.h

 // Copyright (c) 2012 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_CUSTOMIZATION_DOCUMENT_H_
 #define CHROME_BROWSER_CHROMEOS_CUSTOMIZATION_DOCUMENT_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 24 matching lines @@
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 // This test is in global namespace so it must be declared here.
 void Test__InitStartupCustomizationDocument(const std::string& manifest);
 
 namespace chromeos {
 
+class CustomizationWallpaperDownloader;
 class ServicesCustomizationExternalLoader;
 
 namespace system {
 class StatisticsProvider;
 }  // system
 
 // Base class for OEM customization document classes.
 class CustomizationDocument {
  public:
   virtual ~CustomizationDocument();
@@ skipping 73 matching lines @@
   std::vector<std::string> configured_locales_;
   std::string initial_timezone_;
   std::string keyboard_layout_;
 
   DISALLOW_COPY_AND_ASSIGN(StartupCustomizationDocument);
 };
 
 // OEM services customization document class.
 // ServicesCustomizationDocument is fetched from network therefore it is not
 // ready just after creation. Fetching of the manifest should be initiated
-// outside this class by calling StartFetching() method.
+// outside this class by calling StartFetching() or EnsureCustomizationApplied()
+// methods.
 // User of the file should check IsReady before use it.
 class ServicesCustomizationDocument : public CustomizationDocument,
                                       private net::URLFetcherDelegate {
  public:
   static ServicesCustomizationDocument* GetInstance();
 
   // Registers preferences.
   static void RegisterPrefs(PrefRegistrySimple* registry);
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
 
   static const char kManifestUrl[];
 
   // Return true if the customization was applied. Customization is applied only
   // once per machine.
   static bool WasOOBECustomizationApplied();
 
+  // If customization has not been applied, start fetching and applying.
+  void EnsureCustomizationApplied();
+
+  // Returns Closure with the EnsureCustomizationApplied() method.
+  base::Closure EnsureCustomizationAppliedClosure();
+
   // Start fetching customization document.
   void StartFetching();
 
   // Apply customization and save in machine options that customization was
   // applied successfully. Return true if customization was applied.
   bool ApplyOOBECustomization();
 
-  // Returns default wallpaper URL.
-  GURL GetDefaultWallpaperUrl() const;
+  // Returns true if default wallpaper URL attribute found in manifest.
+  // |out_url| is set to attribute value.
+  bool GetDefaultWallpaperUrl(GURL* out_url) const;
 
   // Returns list of default apps.
   bool GetDefaultApps(std::vector<std::string>* ids) const;
 
   // Creates an extensions::ExternalLoader that will provide OEM default apps.
   // Cache of OEM default apps stored in profile preferences.
   extensions::ExternalLoader* CreateExternalLoader(Profile* profile);
 
   // Returns the name of the folder for OEM apps for given |locale|.
   std::string GetOemAppsFolderName(const std::string& locale) const;
 
   // Initialize instance of ServicesCustomizationDocument for tests that will
   // override singleton until ShutdownForTesting is called.
   static void InitializeForTesting();
 
   // Remove instance of ServicesCustomizationDocument for tests.
   static void ShutdownForTesting();
 
+  // These methods are also called by WallpaperManager to get "global default"
+  // customized wallpaper path (and to init default wallpaper path from it)
+  // before first wallpaper is shown.
+  static base::FilePath GetCustomizedWallpaperCacheDir();
+  static base::FilePath GetCustomizedWallpaperDownloadedFileName();
+
  private:
   friend struct DefaultSingletonTraits<ServicesCustomizationDocument>;
 
   typedef std::vector<base::WeakPtr<ServicesCustomizationExternalLoader> >
       ExternalLoaders;
 
+  // Guard for a single application task (wallpaper downloading, for example).
+  class ApplyingTask;
+
   // C-tor for singleton construction.
   ServicesCustomizationDocument();
 
   // C-tor for test construction.
   explicit ServicesCustomizationDocument(const std::string& manifest);
 
   virtual ~ServicesCustomizationDocument();
 
   // Save applied state in machine settings.
   static void SetApplied(bool val);
@@ skipping 32 matching lines @@
   void OnCustomizationNotFound();
 
   // Set OEM apps folder name for AppListSyncableService for |profile|.
   void SetOemFolderName(Profile* profile, const base::DictionaryValue& root);
 
   // Returns the name of the folder for OEM apps for given |locale|.
   std::string GetOemAppsFolderNameImpl(
       const std::string& locale,
       const base::DictionaryValue& root) const;
 
+  // Start download of wallpaper image if needed.
+  void StartOEMWallpaperDownload(const GURL& wallpaper_url,
+                                 scoped_ptr<ApplyingTask> applying);
+
+  // Check that current customized wallpaper cache exists. Once wallpaper is
+  // downloaded, it's never updated (even if manifest is re-fetched).
+  // Start wallpaper download if needed.
+  void CheckAndApplyWallpaper();
+
+  // Intermediate function to pass the result of PathExists to ApplyWallpaper.
+  void OnCheckedWallpaperCacheExists(scoped_ptr<bool> exists,
+                                     scoped_ptr<ApplyingTask> applying);
+
+  // Called after downloaded wallpaper has been checked.
+  void ApplyWallpaper(bool default_wallpaper_file_exists,
+                      scoped_ptr<ApplyingTask> applying);
+
+  // Set Shell default wallpaper to customized.
+  // It's wrapped as a callback and passed as a parameter to
+  // CustomizationWallpaperDownloader.
+  void OnOEMWallpaperDownloaded(scoped_ptr<ApplyingTask> applying,
+                                bool success,
+                                const GURL& wallpaper_url);
+
+  // Register one of Customization applying tasks.
+  void ApplyingTaskStarted();
+
+  // Mark task finished and check for "all customization applied".
+  void ApplyingTaskFinished(bool success);
+
   // Services customization manifest URL.
   GURL url_;
 
   // URLFetcher instance.
   scoped_ptr<net::URLFetcher> url_fetcher_;
 
   // How many times we already tried to fetch customization manifest file.
   int num_retries_;
 
   // Manifest fetch is already in progress.
   bool fetch_started_;
 
   // Delay between checks for network online state.
   base::TimeDelta network_delay_;
 
   // Known external loaders.
   ExternalLoaders external_loaders_;
 
+  scoped_ptr<CustomizationWallpaperDownloader> wallpaper_downloader_;
+
+  // This is barrier until customization is applied.
+  // When number of finished tasks match number of started - customization is
+  // applied.
+  size_t apply_tasks_started_;
+  size_t apply_tasks_finished_;
+
+  // This is the number of successfully finished customization tasks.
+  // If it matches number of tasks finished - customization is applied
+  // successfully.
+  size_t apply_tasks_success_;
+
   // Weak factory for callbacks.
   base::WeakPtrFactory<ServicesCustomizationDocument> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServicesCustomizationDocument);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CUSTOMIZATION_DOCUMENT_H_