Added system log uploader.

chrome/browser/chromeos/policy/system_log_uploader.cc

+// Copyright (c) 2015 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 "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/location.h"
+#include "chrome/browser/chromeos/policy/system_log_delegate.h"
+#include "chrome/browser/chromeos/policy/system_log_uploader.h"
+
+namespace {
+// Determines the time between log uploads.
+const int64 kDefaultUploadDelayMs = 12 * 60 * 60 * 1000;  // 12 hours
+
+// Determines the time, measured from the time of last failed upload,
+// after which the log upload is retried.
+const int64 kErrorUploadDelayMs = 120 * 1000;  // 120 seconds
+
+}  // namespace
+
+namespace policy {
+
+SystemLogUploader::SystemLogUploader(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner)
+    : retrying_(true),
+      upload_frequency_(
+          base::TimeDelta::FromMilliseconds(kDefaultUploadDelayMs)),
+      last_upload_attempt_(base::Time::NowFromSystemTime()),
+      task_runner_(task_runner),
+      weak_factory_(this) {
+  upload_job_.reset();
+
+  // Immediately schedule the next system log upload after upload_frequency_
+  // time from now.
+  ScheduleNextSystemLogUpload(upload_frequency_);
+}
+
+SystemLogUploader::~SystemLogUploader() {
+  upload_job_.reset();
+}
+
+SystemLogUploadJob* SystemLogUploader::CreateSystemLogUploadJob() {
+  return new SystemLogUploadJob(make_scoped_ptr(new SystemLogDelegate()));
+}
+
+void SystemLogUploader::OnSuccess() {
+  // On successful log upload schedule the next log upload after
+  // upload_frequency_ time from now.
+  upload_job_.reset();
+  retrying_ = true;
+  last_upload_attempt_ = base::Time::NowFromSystemTime();
+
+  ScheduleNextSystemLogUpload(upload_frequency_);
+}
+
+void SystemLogUploader::OnFailure() {
+  // On first failure log upload try to re-upload logs after kErrorUploadDelayMs
+  // time from now.
+  upload_job_.reset();
+  last_upload_attempt_ = base::Time::NowFromSystemTime();
+
+  if (retrying_) {
+    ScheduleNextSystemLogUpload(
+        base::TimeDelta::FromMilliseconds(kErrorUploadDelayMs));
+  } else {
+    ScheduleNextSystemLogUpload(upload_frequency_);
+  }
+
+  retrying_ = !retrying_;
+}
+
+void SystemLogUploader::StartLogUpload() {
+  upload_job_.reset(CreateSystemLogUploadJob());
+  upload_job_->Run(
+      base::Bind(&SystemLogUploader::OnSuccess, weak_factory_.GetWeakPtr()),
+      base::Bind(&SystemLogUploader::OnFailure, weak_factory_.GetWeakPtr()));
+}
+
+void SystemLogUploader::ScheduleNextSystemLogUpload(base::TimeDelta frequency) {
+  // Calculate when to fire off the next update.
+  base::TimeDelta delay = std::max(
+      (last_upload_attempt_ + frequency) - base::Time::NowFromSystemTime(),
+      base::TimeDelta());
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&SystemLogUploader::StartLogUpload,
+                                           weak_factory_.GetWeakPtr()),
+                                delay);
+}
+
+}  // namespace policy