Added policy to disable/enable a system log upload.

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/command_line.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 133 matching lines @@
 // Template string constant for populating the name field.
 const char* const SystemLogUploader::kNameFieldTemplate = "file%d";
 
 SystemLogUploader::SystemLogUploader(
     scoped_ptr<Delegate> syslog_delegate,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : retry_count_(0),
       upload_frequency_(GetUploadFrequency()),
       task_runner_(task_runner),
       syslog_delegate_(syslog_delegate.Pass()),
+      upload_enabled_(false),
       weak_factory_(this) {
   if (!syslog_delegate_)
     syslog_delegate_.reset(new SystemLogDelegate());
   DCHECK(syslog_delegate_);
+
+  // Watch for policy changes.
+  upload_enabled_observer_ = chromeos::CrosSettings::Get()->AddSettingsObserver(
+      chromeos::kLogUploadEnabled,
+      base::Bind(&SystemLogUploader::RefreshUploadSettings,
+                 base::Unretained(this)));
+
+  // Fetch the current value of the policy.
+  RefreshUploadSettings();
+
   // Immediately schedule the next system log upload (last_upload_attempt_ is
   // set to the start of the epoch, so this will trigger an update upload in the
   // immediate future).
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 SystemLogUploader::~SystemLogUploader() {}
 
 void SystemLogUploader::OnSuccess() {
   upload_job_.reset();
@@ skipping 15 matching lines @@
   if (retry_count_++ < kMaxNumRetries) {
     ScheduleNextSystemLogUpload(
         base::TimeDelta::FromMilliseconds(kErrorUploadDelayMs));
   } else {
     // No more retries.
     retry_count_ = 0;
     ScheduleNextSystemLogUpload(upload_frequency_);
   }
 }
 
+void SystemLogUploader::RefreshUploadSettings() {
+  // Attempt to fetch the current value of the reporting settings.
+  // If trusted values are not available, register this function to be called
+  // back when they are available.
+  chromeos::CrosSettings* settings = chromeos::CrosSettings::Get();
+  if (chromeos::CrosSettingsProvider::TRUSTED !=
+      settings->PrepareTrustedValues(
+          base::Bind(&SystemLogUploader::RefreshUploadSettings,
+                     weak_factory_.GetWeakPtr()))) {
+    return;
+  }
+
+  // CrosSettings are trusted - we want to use the last trusted values, by
+  // default do not upload system logs.
+  if (!settings->GetBoolean(chromeos::kLogUploadEnabled, &upload_enabled_))
+    upload_enabled_ = false;
+}
+
 void SystemLogUploader::UploadSystemLogs(scoped_ptr<SystemLogs> system_logs) {
   // Must be called on the main thread.
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!upload_job_);
 
   GURL upload_url(kSystemLogUploadUrl);
   DCHECK(upload_url.is_valid());
   upload_job_ = syslog_delegate_->CreateUploadJob(upload_url, this);
 
   // Start a system log upload.
@@ skipping 10 matching lines @@
         header_fields, data.Pass());
     ++file_number;
   }
   upload_job_->Start();
 }
 
 void SystemLogUploader::StartLogUpload() {
   // Must be called on the main thread.
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  syslog_delegate_->LoadSystemLogs(base::Bind(
-      &SystemLogUploader::UploadSystemLogs, weak_factory_.GetWeakPtr()));
+  if (upload_enabled_) {
+    syslog_delegate_->LoadSystemLogs(base::Bind(
+        &SystemLogUploader::UploadSystemLogs, weak_factory_.GetWeakPtr()));
+  } else {
+    // If upload is disabled, schedule the next attempt after 12h.
+    retry_count_ = 0;
+    last_upload_attempt_ = base::Time::NowFromSystemTime();
+    ScheduleNextSystemLogUpload(upload_frequency_);
+  }
 }
 
 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());
   // Ensure that we never have more than one pending delayed task.
   weak_factory_.InvalidateWeakPtrs();
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&SystemLogUploader::StartLogUpload,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 }
 
 }  // namespace policy