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();

[Andrew T Wilson (Slow), 2015/07/03 15:40:48]

Why is this here? Doesn't upload_job_ start as NULL?

[Polina Bondarenko, 2015/07/08 10:07:24]

Done.

+
+  // Immediately schedule the next system log upload after upload_frequency_
+  // time from now.
+  ScheduleNextSystemLogUpload(upload_frequency_);

[Andrew T Wilson (Slow), 2015/07/03 15:40:48]

This means that if you have your device setup to reboot every 11 hours (or it
crashes frequently), it will never upload logs, correct? Just wonder if maybe we
should immediately upload logs after every reboot?

[Polina Bondarenko, 2015/07/08 10:07:24]

Sounds good, let's upload immediately.

+}
+
+SystemLogUploader::~SystemLogUploader() {
+  upload_job_.reset();

[Andrew T Wilson (Slow), 2015/07/03 15:40:48]

Why do this here instead of letting the default destructor handle it?

[Polina Bondarenko, 2015/07/08 10:07:23]

Done.

+}
+
+SystemLogUploadJob* SystemLogUploader::CreateSystemLogUploadJob() {
+  return new SystemLogUploadJob(make_scoped_ptr(new SystemLogDelegate()));

[Andrew T Wilson (Slow), 2015/07/03 15:40:48]

Is SystemLogDelegate used outside this file? Should we move it to an anonymous
namespace in this file?

[Polina Bondarenko, 2015/07/08 10:07:23]

Yes, fixed.

+}
+
+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_;

[Andrew T Wilson (Slow), 2015/07/03 15:40:48]

The logic with retry is somewhat confusing. And it's weird to set retrying_ to
true in the constructor since you haven't even started doing an upload yet so
you can't be retrying.

Maybe just make it retry_count_, initialize it to zero, reset to zero on every
successful upload, increment it on every error, and have a kMaxNumRetries = 1,
so the logic in OnFailure looks like:

if (retry_count_++ < kMaxNumRetries) {
  ScheduleNext(kErrorUploadDelayMs);
} else {
  // No more retries
  retry_count = 0;
  ScheduleNextSystemLogUpload(upload_frequency);
}

That's easier to parse the logic I think.

[Polina Bondarenko, 2015/07/08 10:07:24]

Done.

+}
+
+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