If customization includes default wallpaper, download and apply it.

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 "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/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"
 
@@ skipping 16 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";
 
+const char kCustomizationDefaultWallpaperDir[] = "customization/";

[Dmitry Polukhin, 2014/03/27 04:36:32]

Please add comment, also please avoid injecting '/', use  AppendRelativePath
instead.

[Alexander Alekseev, 2014/03/31 14:15:40]

Done.

+
+// The original downloaded image file is stored under this name.
+const char kCustomizationDefaultWallpaperDownloadedFile[] =
+    "default.downloaded";
+
 // 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 39 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::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(exists);
+  *exists = base::PathExists(path);
+}
+
 }  // anonymous namespace
 
 namespace chromeos {
 
 // 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.
@@ skipping 213 matching lines @@
 // static
 ServicesCustomizationDocument* ServicesCustomizationDocument::GetInstance() {
   return Singleton<ServicesCustomizationDocument,
       DefaultSingletonTraits<ServicesCustomizationDocument> >::get();
 }
 
 // static
 void ServicesCustomizationDocument::RegisterPrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(kServicesCustomizationAppliedPref, false);
+  registry->RegisterStringPref(prefs::kCustomizationDefaultWallpaperURL, "");

[Dmitry Polukhin, 2014/03/27 04:36:32]

I'm bit worry about keeping URL to download file. It could be attack vector to
replace this URL with some malicious URL in local settings (potential cross user
infection path). I think we should re-download customization manifest if fail
was not download and saved to disk at once. We download customization manifest
using HTPS from Google server so it is more reliable sources than URL in local
settings.

[Alexander Alekseev, 2014/03/31 14:15:40]

This URL is never fetched. It's used as a flag that image by this URL has beed
cached. It's only compared to the URL from manifest.

 }
 
 // static
 void ServicesCustomizationDocument::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
       kServicesCustomizationKey,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
@@ skipping 92 matching lines @@
   }
 
   LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_PARSING_ERROR);
   return false;
 }
 
 void ServicesCustomizationDocument::OnManifestLoaded() {
   if (!ServicesCustomizationDocument::WasOOBECustomizationApplied())
     ApplyOOBECustomization();
 
+  CheckAndApplyWallpaper();

[Dmitry Polukhin, 2014/03/27 04:36:32]

Why do you need this??? Wallpaper should be applied only once per machine. But
this code path will be called for every user on the machine.

[Alexander Alekseev, 2014/03/31 14:15:40]

Done.

+
   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()));
       SetOemFolderName((*it)->profile(), *root_);
     }
@@ skipping 28 matching lines @@
     // This doesn't stop fetching manifest on next restart.
     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;
 }
 
+void ServicesCustomizationDocument::StartOEMWallpaperDownload(

[Daniel Erat, 2014/03/27 01:45:50]

please make the order of the methods match between .h and .cc files; the
implementation is difficult to navigate otherwise

[Alexander Alekseev, 2014/03/31 14:15:40]

Done.

+    const GURL& wallpaper_url) {
+  DCHECK(wallpaper_url.is_valid());
+
+  const base::FilePath dir = GetCustomizedWallpaperCacheDir();
+  const base::FilePath file = GetCustomizedWallpaperDownloadedFileName();
+  if (!dir.empty() && !file.empty()) {
+    wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
+        g_browser_process->system_request_context(), wallpaper_url, dir, file));
+
+    wallpaper_downloader_->Start();
+  }
+}
+
+// static
+base::FilePath ServicesCustomizationDocument::GetCustomizedWallpaperCacheDir() {
+  base::FilePath custom_wallpaper_dir;
+  const bool success = PathService::Get(chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS,
+                                        &custom_wallpaper_dir);
+  DCHECK(success);
+
+  if (success)
+    return custom_wallpaper_dir.Append(kCustomizationDefaultWallpaperDir);
+
+  return custom_wallpaper_dir;
+}
+
+// static
+base::FilePath
+    ServicesCustomizationDocument::GetCustomizedWallpaperDownloadedFileName() {
+  const base::FilePath dir = GetCustomizedWallpaperCacheDir();
+  if (dir.empty())
+    return dir;
+  return dir.Append(kCustomizationDefaultWallpaperDownloadedFile);
+}
+
+// static
+void ServicesCustomizationDocument::SetDefaultWallpaperPath(
+    const GURL& wallpaper_url) {

[Daniel Erat, 2014/03/27 01:45:50]

why does this need to be a static method?

[Alexander Alekseev, 2014/03/31 14:15:40]

It just doesn't require access to object. It doesn't need to be static.
Do you think I should still make it "normal" method?

[Daniel Erat, 2014/03/31 14:22:15]

if it doesn't need to be accessed outside of the class, just make it into a
function in the anonymous namespace. this makes the header file smaller and is
easier to maintain (since you don't need to maintain a separate method signature
in the header).

[Alexander Alekseev, 2014/03/31 15:39:15]

It's called from both this class and CustomizationWallpaperDownloader.

+  DCHECK(wallpaper_url.is_valid());
+
+  VLOG(1) << "Setting default wallpaper to '"
+          << GetCustomizedWallpaperDownloadedFileName().value() << "' ('"
+          << wallpaper_url.spec() << "')";
+  WallpaperManager::Get()->SetCustomizedDefaultWallpaper(
+      wallpaper_url,
+      GetCustomizedWallpaperDownloadedFileName(),
+      GetCustomizedWallpaperCacheDir());
+}
+
+// static
+void ServicesCustomizationDocument::DestroyWallpaperDownloader() {
+  ServicesCustomizationDocument* self =
+      ServicesCustomizationDocument::GetInstance();

[Daniel Erat, 2014/03/27 01:45:50]

why does this need to be a static method? can't the caller just call
GetInstance() itself?

[Dmitry Polukhin, 2014/03/27 04:36:32]

I think we need to use weak pointers that comes from parameter here. Otherwise
we might face crashes on browser shutdown when ServicesCustomizationDocument is
destroyed.

[Alexander Alekseev, 2014/03/31 14:15:40]

Done.

[Alexander Alekseev, 2014/03/31 14:15:40]

I don't see the way to crash here, as Singleton will be reinitialized on Get().
Also, CustomizedWallpaperDownloader is owned by ServicedCustomizationDocument,
so it should be destroyed before owner.

+  DCHECK(self);
+  self->wallpaper_downloader_.reset();
+}
+
+void ServicesCustomizationDocument::ApplyWallpaper(
+    bool default_wallpaper_file_exists) {
+  GURL wallpaper_url = GetDefaultWallpaperUrl();
+  DCHECK(wallpaper_url.is_valid());

[Dmitry Polukhin, 2014/03/27 04:36:32]

Could you please add checks for expect thread for each method that is called
with PostTask?

[Alexander Alekseev, 2014/03/31 14:15:40]

All of them already have these checks. ApplyWallpaper is never called with
PostTask.

+
+  PrefService* pref_service = g_browser_process->local_state();
+
+  std::string current_url =
+      pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
+  if (current_url != wallpaper_url.spec()) {
+    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.");
+  }
+  // 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";
+    SetDefaultWallpaperPath(GURL(current_url));
+  } else {
+    VLOG(1)
+        << "ServicesCustomizationDocument::ApplyWallpaper() : start download";
+    StartOEMWallpaperDownload(wallpaper_url);
+  }
+}
+
+void ServicesCustomizationDocument::OnCheckedWallpaperCacheExists(
+    scoped_ptr<bool> exists) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(exists.get());
+
+  ApplyWallpaper(*exists);
+}
+
+void ServicesCustomizationDocument::CheckAndApplyWallpaper() {
+  if (wallpaper_downloader_.get()) {
+    VLOG(1) << "CheckAndApplyWallpaper(): download has already started.";
+    return;
+  }
+  GURL wallpaper_url = GetDefaultWallpaperUrl();
+  // Should fail if this ever happens in tests.
+  DCHECK(wallpaper_url.is_valid() || wallpaper_url.is_empty());
+  if (!wallpaper_url.is_valid()) {
+    if (!wallpaper_url.is_empty()) {
+      LOG(WARNING) << "Invalid Customized Wallpaper URL.";
+    }
+    return;
+  }
+  scoped_ptr<bool> exists(new bool(false));

[Dmitry Polukhin, 2014/03/27 04:36:32]

I don't like this approach to me it would be cleaner to pass callback to
callback that will be called if file exists. scoped_ptr<bool> looks very
suspicious.

[Alexander Alekseev, 2014/03/31 14:15:40]

This approach guarantees that WeakPointer never leaves UI thread, so it will be
destroyed on UI thread. Passing callback with WeakPointer to another thread
means it would be once destroyed there.

I can do what you want, but would you accept current approach instead? 

+
+  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()));
+  if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
+          FROM_HERE, check_file_exists, on_checked_closure)) {
+    LOG(WARNING) << "Failed to start check Wallpaper cache exists.";
+  }
+}
+
 bool ServicesCustomizationDocument::ApplyOOBECustomization() {
-  // TODO(dpolukhin): apply default wallpaper, crbug.com/348136.
   SetApplied(true);
   return true;
 }
 
 GURL ServicesCustomizationDocument::GetDefaultWallpaperUrl() const {
   if (!IsReady())
     return GURL();
 
   std::string url;
   root_->GetString(kDefaultWallpaperAttr, &url);
@@ skipping 110 matching lines @@
 }
 
 std::string ServicesCustomizationDocument::GetOemAppsFolderNameImpl(
     const std::string& locale,
     const base::DictionaryValue& root) const {
   return GetLocaleSpecificStringImpl(
       &root, locale, kLocalizedContent, kDefaultAppsFolderName);
 }
 
 }  // namespace chromeos