Apply default wallpaper from customization manifest.

chrome/browser/chromeos/customization_wallpaper_downloader.cc

Index: chrome/browser/chromeos/customization_wallpaper_downloader.cc
diff --git a/chrome/browser/chromeos/customization_wallpaper_downloader.cc b/chrome/browser/chromeos/customization_wallpaper_downloader.cc
new file mode 100644
index 0000000000000000000000000000000000000000..90ae00c049e27502bce985aeb36adb8aaf3ad298
--- /dev/null
+++ b/chrome/browser/chromeos/customization_wallpaper_downloader.cc
@@ -0,0 +1,189 @@
+// 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.
+
+#include "chrome/browser/chromeos/customization_wallpaper_downloader.h"
+
+#include "base/file_util.h"
+#include "chrome/browser/chromeos/customization_document.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/load_flags.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "url/gurl.h"
+
+namespace {
+// This is temporary file suffix (for downloading or resizing).
+const char kTemporarySuffix[] = ".temp";
+
+// Sleep between wallpaper retries (used multiplied by retry number).
+const unsigned kRetrySleepSeconds = 10;
+
+// Do not increase retry sleep beyond this number of attempts.
+const unsigned kRetriesInfinite = 30;
+}
+
+namespace chromeos {
+
+CustomizationWallpaperDownloader::CustomizationWallpaperDownloader(
+    net::URLRequestContextGetter* url_context_getter,
+    const GURL& wallpaper_url,
+    const base::FilePath& wallpaper_dir,
+    const base::FilePath& wallpaper_downloaded_file)
+    : url_context_getter_(url_context_getter),
+      wallpaper_url_(wallpaper_url),
+      wallpaper_dir_(wallpaper_dir),
+      wallpaper_downloaded_file_(wallpaper_downloaded_file),
+      wallpaper_temporary_file_(wallpaper_downloaded_file.value() +
+                                kTemporarySuffix),
+      retries_(0),
+      weak_factory_(this) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+}
+
+CustomizationWallpaperDownloader::~CustomizationWallpaperDownloader() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+}
+
+void CustomizationWallpaperDownloader::StartRequest() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(wallpaper_url_.is_valid());
+  ++retries_;
+
+  url_fetcher_.reset(
+      net::URLFetcher::Create(wallpaper_url_, net::URLFetcher::GET, this));
+  url_fetcher_->SetRequestContext(url_context_getter_);
+  url_fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
+                             net::LOAD_DO_NOT_SAVE_COOKIES |
+                             net::LOAD_DO_NOT_SEND_COOKIES |
+                             net::LOAD_DO_NOT_SEND_AUTH_DATA);
+  base::SequencedWorkerPool* blocking_pool =
+      content::BrowserThread::GetBlockingPool();
+  url_fetcher_->SaveResponseToFileAtPath(
+      wallpaper_temporary_file_,
+      blocking_pool->GetSequencedTaskRunner(blocking_pool->GetSequenceToken()));
+  url_fetcher_->Start();

[Dmitry Polukhin, 2014/04/11 23:17:17]

Perhaps you need to check network condition to don't retry when there is no
connectivity or under captive portal.

[Alexander Alekseev, 2014/04/12 01:42:30]

I can use DelayNetworkCall here, but I think it adds extra complexity here.
Wallpaper download is started after successful manifest fetch, so why add
another portal check?

+}
+
+void CustomizationWallpaperDownloader::Retry() {

[Dmitry Polukhin, 2014/04/11 23:17:17]

We need to give up after several retries to don't overload server. Also perhaps
we should remember that file doesn't exist on server to don't retry forever.

[Alexander Alekseev, 2014/04/12 01:42:30]

If file doesn't exist, it usually means "temporary server error".
To make the retries less expensive, the timeout is increasing here.
Let's stop after 200 requests. (It is actually 2 days due to increasing
timeout.).

[Dmitry Polukhin, 2014/04/14 20:26:37]

Because you don't remember throttling info between sessions. There is very good
chance that you may never have 2 days of working time to give up. We need to
think about some throttling very carefully so Chrome won't keep pinging server
for every user on the machine separately. Perhaps we should preserver throttling
info in Local State.

[Alexander Alekseev, 2014/04/15 01:57:16]

The idea was to increase delay fast enough to make remembering throttling
useless. Probably I should implement even faster delay like power series. 

+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  const unsigned delay_multiplier =
+      (retries_ > kRetriesInfinite ? kRetriesInfinite : retries_);
+  const base::TimeDelta delay =
+      base::TimeDelta::FromSeconds(kRetrySleepSeconds) * delay_multiplier;
+  VLOG(1) << "Schedule Customized Wallpaper download in " << delay.InSecondsF()
+          << " seconds.";
+  request_scheduled_.Start(
+      FROM_HERE, delay, this, &CustomizationWallpaperDownloader::StartRequest);
+}
+
+void CustomizationWallpaperDownloader::Start() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  scoped_ptr<bool> success(new bool(false));
+
+  base::Closure mkdir_closure =
+      base::Bind(&CustomizationWallpaperDownloader::CreateWallpaperDirectory,
+                 wallpaper_dir_,
+                 base::Unretained(success.get()));
+  base::Closure on_created_closure =
+      base::Bind(&CustomizationWallpaperDownloader::OnWallpaperDirectoryCreated,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(success.Pass()));
+  if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
+          FROM_HERE, mkdir_closure, on_created_closure)) {
+    LOG(WARNING) << "Failed to start Customized Wallpaper download.";
+  }
+}
+
+// static
+void CustomizationWallpaperDownloader::CreateWallpaperDirectory(
+    const base::FilePath& wallpaper_dir,
+    bool* success) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(success);
+
+  *success = CreateDirectoryAndGetError(wallpaper_dir, NULL);
+}
+
+void CustomizationWallpaperDownloader::OnWallpaperDirectoryCreated(
+    scoped_ptr<bool> success) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (*success)
+    StartRequest();
+}
+
+void CustomizationWallpaperDownloader::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_EQ(url_fetcher_.get(), source);
+
+  const net::URLRequestStatus status = source->GetStatus();
+  const int response_code = source->GetResponseCode();
+
+  const bool server_error =
+      !status.is_success() || (response_code >= 500 && response_code < 600);
+
+  VLOG(1) << "CustomizationWallpaperDownloader::OnURLFetchComplete(): status="
+          << status.status();
+
+  if (server_error) {
+    url_fetcher_.reset();
+    Retry();
+    return;
+  }
+
+  base::FilePath response_path;
+  url_fetcher_->GetResponseAsFilePath(true, &response_path);
+  url_fetcher_.reset();
+
+  scoped_ptr<bool> success(new bool(false));
+
+  base::Closure rename_closure =
+      base::Bind(&CustomizationWallpaperDownloader::RenameTemporaryFile,
+                 response_path,
+                 wallpaper_downloaded_file_,
+                 base::Unretained(success.get()));
+  base::Closure on_rename_closure =
+      base::Bind(&CustomizationWallpaperDownloader::OnTemporaryFileRenamed,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(success.Pass()));
+  if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
+          FROM_HERE, rename_closure, on_rename_closure)) {
+    LOG(WARNING)
+        << "Failed to start Customized Wallpaper Rename DownloadedFile.";
+    // Destroy self.
+    ServicesCustomizationDocument::GetInstance()->DestroyWallpaperDownloader();

[Dmitry Polukhin, 2014/04/11 23:17:17]

I think you can just delete self if ServicesCustomizationDocument will keep
WeakPtr to CustomizationWallpaperDownloader. Alternative that
ServicesCustomizationDocument may not keep pointer
toCustomizationWallpaperDownloader (it is not really used anyway). 

[Alexander Alekseev, 2014/04/12 01:42:30]

I think this would lead to problems in tests. Our tests work better
with hierarchical objects, because even singletons are destroyed in tests (and
in unit tests destruction happens on arbitrary threads).

[Dmitry Polukhin, 2014/04/14 20:26:37]

Singletons shouldn't be a problem in test if you use ShadowingAtExitManager to
destroy all singletons after running test. Design decision with
DestroyWallpaperDownloader looks very ugly and we should fine better solution,
for example WeakPointers, RefCounting or something else.
DestroyWallpaperDownloader shouldn't be part of public interface of
ServicesCustomizationDocument, friendship is also not a solution.

[Alexander Alekseev, 2014/04/15 01:57:16]

I've dropped DestroyWallpaperDownloader method.

+  }
+}
+
+void CustomizationWallpaperDownloader::OnTemporaryFileRenamed(
+    scoped_ptr<bool> success) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!success) {
+    // Destroy self.
+    ServicesCustomizationDocument::GetInstance()->DestroyWallpaperDownloader();
+    return;
+  }
+  ServicesCustomizationDocument::OnCustomizedWallpaperDownloaded(
+      wallpaper_url_);
+}
+
+// static
+void CustomizationWallpaperDownloader::RenameTemporaryFile(
+    const base::FilePath& from,
+    const base::FilePath& to,
+    bool* success) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(success);
+
+  base::File::Error error;
+  if (ReplaceFile(from, to, &error)) {
+    *success = true;
+  } else {
+    LOG(WARNING)
+        << "Failed to rename temporary file of Customized Wallpaper. error="
+        << error;
+    *success = false;
+  }
+}
+
+}  //   namespace chromeos