Apply default wallpaper from customization manifest.

chrome/browser/chromeos/customization_document.cc

 // 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.
 
 #include "chrome/browser/chromeos/customization_document.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
+#include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/customization_wallpaper_downloader.h"
 #include "chrome/browser/chromeos/extensions/default_app_order.h"
+#include "chrome/browser/chromeos/login/wallpaper_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/net/delay_network_call.h"
 #include "chrome/browser/extensions/external_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/pref_names.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 17 matching lines @@
 const char kDefaultAppsAttr[] = "default_apps";
 const char kLocalizedContent[] = "localized_content";
 const char kDefaultAppsFolderName[] = "default_apps_folder_name";
 
 const char kAcceptedManifestVersion[] = "1.0";
 
 // Path to OEM partner startup customization manifest.
 const char kStartupCustomizationManifestPath[] =
     "/opt/oem/etc/startup_manifest.json";
 
+// This is subdirectory relative to PathService(DIR_CHROMEOS_CUSTOM_WALLPAPERS),
+// where downloaded (and resized) wallpaper is stored.
+const char kCustomizationDefaultWallpaperDir[] = "customization";
+
+// The original downloaded image file is stored under this name.
+const char kCustomizationDefaultWallpaperDownloadedFile[] =
+    "default_downloaded_wallpaper.bin";
+
 // Name of local state option that tracks if services customization has been
 // applied.
 const char kServicesCustomizationAppliedPref[] = "ServicesCustomizationApplied";
 
 // Maximum number of retries to fetch file if network is not available.
 const int kMaxFetchRetries = 3;
 
 // Delay between file fetch retries if network is not available.
 const int kRetriesDelayInSec = 2;
 
@@ skipping 42 matching lines @@
   const base::DictionaryValue* default_dictionary = NULL;
   if (dictionary_content->GetDictionary(kDefaultAttr, &default_dictionary)) {
     std::string result;
     if (default_dictionary->GetString(entry_name, &result))
       return result;
   }
 
   return std::string();
 }
 
+void CheckWallpaperCacheExists(const base::FilePath& path, bool* exists) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(exists);
+  *exists = base::PathExists(path);
+}
+
 }  // anonymous namespace
 
 // Template URL where to fetch OEM services customization manifest from.
 const char ServicesCustomizationDocument::kManifestUrl[] =
     "https://ssl.gstatic.com/chrome/chromeos-customization/%s.json";
 
 // A custom extensions::ExternalLoader that the ServicesCustomizationDocument
 // creates and uses to publish OEM default apps to the extensions system.
 class ServicesCustomizationExternalLoader
     : public extensions::ExternalLoader,
@@ skipping 10 matching lines @@
     is_apps_set_ = true;
     StartLoading();
   }
 
   // Implementation of extensions::ExternalLoader:
   virtual void StartLoading() OVERRIDE {
     if (!is_apps_set_) {
       ServicesCustomizationDocument::GetInstance()->StartFetching();
       // In case of missing customization ID, SetCurrentApps will be called
       // synchronously from StartFetching and this function will be called
-      // recursively so we need to return to don't call LoadFinished twice.
+      // recursively so we need to return to avoid calling LoadFinished twice.
       // In case of async load it is safe to return empty list because this
       // provider didn't install any app yet so no app can be removed due to
       // returning empty list.
       if (is_apps_set_)
         return;
     }
 
     prefs_.reset(apps_.DeepCopy());
     VLOG(1) << "ServicesCustomization extension loader publishing "
             << apps_.size() << " apps.";
@@ skipping 160 matching lines @@
   return configured_locales_.front();
 }
 
 std::string StartupCustomizationDocument::GetEULAPage(
     const std::string& locale) const {
   return GetLocaleSpecificString(locale, kSetupContentAttr, kEulaPageAttr);
 }
 
 // ServicesCustomizationDocument implementation. -------------------------------
 
+class ServicesCustomizationDocument::ApplyingTask {
+ public:
+  // Registers in ServicesCustomizationDocument;
+  explicit ApplyingTask(ServicesCustomizationDocument* document);
+
+  // Do not automatically deregister as we might be called on invalid thread.
+  ~ApplyingTask();
+
+  // Mark task finished and check for customization applied.
+  void Finished(bool success);
+
+ private:
+  ServicesCustomizationDocument* document_;
+
+  // This is error-checking flag to prevent destroying unfinished task
+  // or double finish.
+  bool engaged_;
+};
+
+ServicesCustomizationDocument::ApplyingTask::ApplyingTask(
+    ServicesCustomizationDocument* document)
+    : document_(document), engaged_(true) {
+  document->ApplyingTaskStarted();
+}
+
+ServicesCustomizationDocument::ApplyingTask::~ApplyingTask() {
+  DCHECK(!engaged_);
+}
+
+void ServicesCustomizationDocument::ApplyingTask::Finished(bool success) {
+  DCHECK(engaged_);
+  if (engaged_) {
+    engaged_ = false;
+    document_->ApplyingTaskFinished(success);
+  }
+}
+
 ServicesCustomizationDocument::ServicesCustomizationDocument()
     : CustomizationDocument(kAcceptedManifestVersion),
       num_retries_(0),
       fetch_started_(false),
-      network_delay_(base::TimeDelta::FromMilliseconds(
-          kDefaultNetworkRetryDelayMS)),
+      network_delay_(
+          base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS)),
+      apply_tasks_started_(0),
+      apply_tasks_finished_(0),
+      apply_tasks_success_(0),
       weak_ptr_factory_(this) {
 }
 
 ServicesCustomizationDocument::ServicesCustomizationDocument(
     const std::string& manifest)
     : CustomizationDocument(kAcceptedManifestVersion),
-      network_delay_(base::TimeDelta::FromMilliseconds(
-          kDefaultNetworkRetryDelayMS)),
+      network_delay_(
+          base::TimeDelta::FromMilliseconds(kDefaultNetworkRetryDelayMS)),
+      apply_tasks_started_(0),
+      apply_tasks_finished_(0),
+      apply_tasks_success_(0),
       weak_ptr_factory_(this) {
   LoadManifestFromString(manifest);
 }
 
 ServicesCustomizationDocument::~ServicesCustomizationDocument() {}
 
 // static
 ServicesCustomizationDocument* ServicesCustomizationDocument::GetInstance() {
   if (g_test_services_customization_document)
     return g_test_services_customization_document;
 
   return Singleton<ServicesCustomizationDocument,
       DefaultSingletonTraits<ServicesCustomizationDocument> >::get();
 }
 
 // static
 void ServicesCustomizationDocument::RegisterPrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(kServicesCustomizationAppliedPref, false);
+  registry->RegisterStringPref(prefs::kCustomizationDefaultWallpaperURL,
+                               std::string());
 }
 
 // static
 void ServicesCustomizationDocument::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
       kServicesCustomizationKey,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 bool ServicesCustomizationDocument::WasOOBECustomizationApplied() {
   PrefService* prefs = g_browser_process->local_state();
   // prefs can be NULL in some tests.
   if (prefs)
     return prefs->GetBoolean(kServicesCustomizationAppliedPref);
   else
     return false;
 }
 
 // static
 void ServicesCustomizationDocument::SetApplied(bool val) {
   PrefService* prefs = g_browser_process->local_state();
   // prefs can be NULL in some tests.
   if (prefs)
     prefs->SetBoolean(kServicesCustomizationAppliedPref, val);
 }
 
+// static
+base::FilePath ServicesCustomizationDocument::GetCustomizedWallpaperCacheDir() {
+  base::FilePath custom_wallpaper_dir;
+  if (!PathService::Get(chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS,
+                        &custom_wallpaper_dir)) {
+    LOG(DFATAL) << "Unable to get custom wallpaper dir.";
+    return base::FilePath();
+  }
+  return custom_wallpaper_dir.Append(kCustomizationDefaultWallpaperDir);
+}
+
+// static
+base::FilePath
+ServicesCustomizationDocument::GetCustomizedWallpaperDownloadedFileName() {
+  const base::FilePath dir = GetCustomizedWallpaperCacheDir();
+  if (dir.empty()) {
+    NOTREACHED();
+    return dir;
+  }
+  return dir.Append(kCustomizationDefaultWallpaperDownloadedFile);
+}
+
+void ServicesCustomizationDocument::EnsureCustomizationApplied() {
+  if (WasOOBECustomizationApplied())
+    return;
+
+  // When customization manifest is fetched, applying will start automatically.
+  if (IsReady())
+    return;
+
+  StartFetching();
+}
+
+base::Closure
+ServicesCustomizationDocument::EnsureCustomizationAppliedClosure() {
+  return base::Bind(&ServicesCustomizationDocument::EnsureCustomizationApplied,
+                    weak_ptr_factory_.GetWeakPtr());
+}
+
 void ServicesCustomizationDocument::StartFetching() {
   if (IsReady() || fetch_started_)
     return;
 
   if (!url_.is_valid()) {
     std::string customization_id;
     chromeos::system::StatisticsProvider* provider =
         chromeos::system::StatisticsProvider::GetInstance();
     if (provider->GetMachineStatistic(system::kCustomizationIdKey,
                                       &customization_id) &&
         !customization_id.empty()) {
       url_ = GURL(base::StringPrintf(
           kManifestUrl, StringToLowerASCII(customization_id).c_str()));
     } else {
-      // There is no customization ID in VPD remember that.
+      // Remember that there is no customization ID in VPD.
       OnCustomizationNotFound();
       return;
     }
   }
 
   if (url_.is_valid()) {
     fetch_started_ = true;
     if (url_.SchemeIsFile()) {
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
           base::Bind(&ServicesCustomizationDocument::ReadFileInBackground,
@@ skipping 56 matching lines @@
     LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_SUCCESS);
     OnManifestLoaded();
     return true;
   }
 
   LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_PARSING_ERROR);
   return false;
 }
 
 void ServicesCustomizationDocument::OnManifestLoaded() {
-  if (!ServicesCustomizationDocument::WasOOBECustomizationApplied())
+  if (!WasOOBECustomizationApplied())
     ApplyOOBECustomization();
 
   scoped_ptr<base::DictionaryValue> prefs =
       GetDefaultAppsInProviderFormat(*root_);
   for (ExternalLoaders::iterator it = external_loaders_.begin();
        it != external_loaders_.end(); ++it) {
     if (*it) {
       UpdateCachedManifest((*it)->profile());
       (*it)->SetCurrentApps(
           scoped_ptr<base::DictionaryValue>(prefs->DeepCopy()));
@@ skipping 31 matching lines @@
     LOG(ERROR) << "URL fetch for services customization failed:"
                << " response code = " << source->GetResponseCode()
                << " URL = " << source->GetURL().spec();
 
     LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_RETRIES_FAIL);
   }
   fetch_started_ = false;
 }
 
 bool ServicesCustomizationDocument::ApplyOOBECustomization() {
-  // TODO(dpolukhin): apply default wallpaper, crbug.com/348136.
-  SetApplied(true);
+  if (apply_tasks_started_)
+    return false;
+
+  CheckAndApplyWallpaper();
+  return false;
+}
+
+bool ServicesCustomizationDocument::GetDefaultWallpaperUrl(
+    GURL* out_url) const {
+  if (!IsReady())
+    return false;
+
+  std::string url;
+  if (!root_->GetString(kDefaultWallpaperAttr, &url))
+    return false;
+
+  *out_url = GURL(url);
   return true;
 }
 
-GURL ServicesCustomizationDocument::GetDefaultWallpaperUrl() const {
-  if (!IsReady())
-    return GURL();
-
-  std::string url;
-  root_->GetString(kDefaultWallpaperAttr, &url);
-  return GURL(url);
-}
-
 bool ServicesCustomizationDocument::GetDefaultApps(
     std::vector<std::string>* ids) const {
   ids->clear();
   if (!IsReady())
     return false;
 
   base::ListValue* apps_list = NULL;
   if (!root_->GetList(kDefaultAppsAttr, &apps_list))
     return false;
 
@@ skipping 110 matching lines @@
   g_test_services_customization_document = new ServicesCustomizationDocument;
   g_test_services_customization_document->network_delay_ = base::TimeDelta();
 }
 
 // static
 void ServicesCustomizationDocument::ShutdownForTesting() {
   delete g_test_services_customization_document;
   g_test_services_customization_document = NULL;
 }
 
+void ServicesCustomizationDocument::StartOEMWallpaperDownload(
+    const GURL& wallpaper_url,
+    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+  DCHECK(wallpaper_url.is_valid());
+
+  const base::FilePath dir = GetCustomizedWallpaperCacheDir();
+  const base::FilePath file = GetCustomizedWallpaperDownloadedFileName();
+  if (dir.empty() || file.empty()) {
+    NOTREACHED();
+    applying->Finished(false);
+    return;
+  }
+
+  wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
+      g_browser_process->system_request_context(),
+      wallpaper_url,
+      dir,
+      file,
+      base::Bind(&ServicesCustomizationDocument::OnOEMWallpaperDownloaded,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(applying.Pass()))));
+
+  wallpaper_downloader_->Start();
+}
+
+void ServicesCustomizationDocument::CheckAndApplyWallpaper() {
+  if (wallpaper_downloader_.get()) {
+    VLOG(1) << "CheckAndApplyWallpaper(): download has already started.";
+    return;
+  }
+  scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying(
+      new ServicesCustomizationDocument::ApplyingTask(this));
+
+  GURL wallpaper_url;
+  if (!GetDefaultWallpaperUrl(&wallpaper_url)) {
+    PrefService* pref_service = g_browser_process->local_state();
+    std::string current_url =
+        pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
+    if (!current_url.empty()) {
+      VLOG(1) << "ServicesCustomizationDocument::CheckAndApplyWallpaper() : "
+              << "No wallpaper URL attribute in customization document, "
+              << "but current value is non-empty: '" << current_url
+              << "'. Ignored.";
+    }
+    applying->Finished(true);
+    return;
+  }
+
+  // Should fail if this ever happens in tests.
+  DCHECK(wallpaper_url.is_valid());
+  if (!wallpaper_url.is_valid()) {
+    if (!wallpaper_url.is_empty()) {
+      LOG(WARNING) << "Invalid Customized Wallpaper URL '"
+                   << wallpaper_url.spec() << "'.";
+    }
+    applying->Finished(false);
+    return;
+  }
+
+  scoped_ptr<bool> exists(new bool(false));
+
+  base::Closure check_file_exists =
+      base::Bind(&CheckWallpaperCacheExists,
+                 GetCustomizedWallpaperDownloadedFileName(),
+                 base::Unretained(exists.get()));
+  base::Closure on_checked_closure =
+      base::Bind(&ServicesCustomizationDocument::OnCheckedWallpaperCacheExists,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(exists.Pass()),
+                 base::Passed(applying.Pass()));
+  if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
+          FROM_HERE, check_file_exists, on_checked_closure)) {
+    LOG(WARNING) << "Failed to start check Wallpaper cache exists.";
+  }
+}
+
+void ServicesCustomizationDocument::OnCheckedWallpaperCacheExists(
+    scoped_ptr<bool> exists,
+    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(exists);
+  DCHECK(applying);
+
+  ApplyWallpaper(*exists, applying.Pass());
+}
+
+void ServicesCustomizationDocument::ApplyWallpaper(
+    bool default_wallpaper_file_exists,
+    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+  GURL wallpaper_url;
+  const bool wallpaper_url_present = GetDefaultWallpaperUrl(&wallpaper_url);
+
+  PrefService* pref_service = g_browser_process->local_state();
+
+  std::string current_url =
+      pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
+  if (current_url != wallpaper_url.spec()) {
+    if (wallpaper_url_present) {
+      VLOG(1) << "ServicesCustomizationDocument::ApplyWallpaper() : "
+              << "Wallpaper URL in customization document '"
+              << wallpaper_url.spec() << "' differs from current '"
+              << current_url << "'."
+              << (GURL(current_url).is_valid() && default_wallpaper_file_exists
+                      ? " Ignored."
+                      : " Will refetch.");
+    } else {
+      VLOG(1) << "ServicesCustomizationDocument::ApplyWallpaper() : "
+              << "No wallpaper URL attribute in customization document, "
+              << "but current value is non-empty: '" << current_url
+              << "'. Ignored.";
+    }
+  }
+  if (!wallpaper_url_present) {
+    applying->Finished(true);
+    return;
+  }
+
+  DCHECK(wallpaper_url.is_valid());
+
+  // Never update system-wide wallpaper (i.e. do not check
+  // current_url == wallpaper_url.spec() )
+  if (GURL(current_url).is_valid() && default_wallpaper_file_exists) {
+    VLOG(1)
+        << "ServicesCustomizationDocument::ApplyWallpaper() : reuse existing";
+    OnOEMWallpaperDownloaded(applying.Pass(), true, GURL(current_url));
+  } else {
+    VLOG(1)
+        << "ServicesCustomizationDocument::ApplyWallpaper() : start download";
+    StartOEMWallpaperDownload(wallpaper_url, applying.Pass());
+  }
+}
+
+void ServicesCustomizationDocument::OnOEMWallpaperDownloaded(
+    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying,
+    bool success,
+    const GURL& wallpaper_url) {
+  if (success) {
+    DCHECK(wallpaper_url.is_valid());
+
+    VLOG(1) << "Setting default wallpaper to '"
+            << GetCustomizedWallpaperDownloadedFileName().value() << "' ('"
+            << wallpaper_url.spec() << "')";
+    WallpaperManager::Get()->SetCustomizedDefaultWallpaper(
+        wallpaper_url,
+        GetCustomizedWallpaperDownloadedFileName(),
+        GetCustomizedWallpaperCacheDir());
+  }
+  wallpaper_downloader_.reset();
+  applying->Finished(success);
+}
+
+void ServicesCustomizationDocument::ApplyingTaskStarted() {
+  ++apply_tasks_started_;
+}
+
+void ServicesCustomizationDocument::ApplyingTaskFinished(bool success) {
+  DCHECK_GT(apply_tasks_started_, apply_tasks_finished_);
+  ++apply_tasks_finished_;
+
+  apply_tasks_success_ += success;
+
+  if (apply_tasks_started_ != apply_tasks_finished_)
+    return;
+
+  if (apply_tasks_success_ == apply_tasks_finished_)
+    SetApplied(true);
+}
+
 }  // namespace chromeos