Added policy to disable/enable a system log upload.

chrome/browser/chromeos/policy/system_log_uploader_unittest.cc

Index: chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
diff --git a/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc b/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
index a1e16e7b76d817fac13fac6d8c75bc02eee4eb8a..756f722dfd235b2eea0585ac966e2a5ce53f1a98 100644
--- a/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
+++ b/chrome/browser/chromeos/policy/system_log_uploader_unittest.cc
@@ -6,6 +6,9 @@
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/policy/system_log_uploader.h"
+#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "net/http/http_request_headers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -110,6 +113,7 @@ class MockSystemLogDelegate : public SystemLogUploader::Delegate {
   ~MockSystemLogDelegate() override {}
 
   void LoadSystemLogs(const LogUploadCallback& upload_callback) override {
+    EXPECT_TRUE(is_upload_allowed_);
     upload_callback.Run(
         make_scoped_ptr(new SystemLogUploader::SystemLogs(system_logs_)));
   }
@@ -121,7 +125,12 @@ class MockSystemLogDelegate : public SystemLogUploader::Delegate {
                                              system_logs_.size()));
   }
 
+  void set_upload_allowed(bool is_upload_allowed) {
+    is_upload_allowed_ = is_upload_allowed;
+  }
+
  private:
+  bool is_upload_allowed_;
   bool is_upload_error_;
   SystemLogUploader::SystemLogs system_logs_;
 };
@@ -132,20 +141,20 @@ class SystemLogUploaderTest : public testing::Test {
  public:
   SystemLogUploaderTest() : task_runner_(new base::TestSimpleTaskRunner()) {}
 
+  void TearDown() override { content::RunAllBlockingPoolTasksUntilIdle(); }
+
   // Given a pending task to upload system logs.
-  void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader,
-                                        base::TimeDelta expected_delay) {
+  void RunPendingUploadTaskAndCheckNext(base::TimeDelta expected_delay) {
     EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
     task_runner_->RunPendingTasks();
 
     // The previous task should have uploaded another log upload task.
     EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-    CheckPendingTaskDelay(uploader, expected_delay);
+    CheckPendingTaskDelay(expected_delay);
   }
 
-  void CheckPendingTaskDelay(const SystemLogUploader& uploader,
-                             base::TimeDelta expected_delay) {
+  void CheckPendingTaskDelay(base::TimeDelta expected_delay) {
     // The next task should be scheduled sometime between
     // |last_upload_attempt| + |expected_delay| and
     // |now| + |expected_delay|.
@@ -153,49 +162,81 @@ class SystemLogUploaderTest : public testing::Test {
     base::Time next_task = now + task_runner_->NextPendingTaskDelay();
 
     EXPECT_LE(next_task, now + expected_delay);
-    EXPECT_GE(next_task, uploader.last_upload_attempt() + expected_delay);
+    EXPECT_GE(next_task, uploader_->last_upload_attempt() + expected_delay);
   }
 
+  void InitTestCase(scoped_ptr<MockSystemLogDelegate> delegate) {
+    // Replace settings provider must be after observer creation in the system

[Andrew T Wilson (Slow), 2015/08/13 11:26:18]

Why is the ordering important? I'm not sure I understand?

[Polina Bondarenko, 2015/08/13 14:51:16]

Yes, you're right, it's not important, removed it.

+    // log uploader's constructor.
+    uploader_.reset(new SystemLogUploader(delegate.Pass(), task_runner_));
+    settings_helper_.ReplaceProvider(chromeos::kLogUploadEnabled);
+  }
+
+  void DestroyTestCase() { settings_helper_.RestoreProvider(); }
+
+ protected:
+  content::TestBrowserThreadBundle thread_bundle_;
+  chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_ptr<SystemLogUploader> uploader_;
 };
 
+// Turn off system log uploads.
+TEST_F(SystemLogUploaderTest, Basic) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(false);
+  InitTestCase(syslog_delegate.Pass());

[Andrew T Wilson (Slow), 2015/08/13 11:26:18]

It's a bit weird to have this Init/DestroyTestCase() stuff. Is it not possible
to have this in the SetUp()/TearDown() code?

[Polina Bondarenko, 2015/08/13 14:51:17]

Yes, it's possible, done.

+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false);
+
+  task_runner_->RunPendingTasks();
+  DestroyTestCase();
+}
+
 // One success task pending.
 TEST_F(SystemLogUploaderTest, SuccessTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate(
-                                 false, SystemLogUploader::SystemLogs())),
-                             task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(true);
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
 }
 
 // Three failed responses recieved.
 TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
-  SystemLogUploader uploader(make_scoped_ptr(new MockSystemLogDelegate(
-                                 true, SystemLogUploader::SystemLogs())),
-                             task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
+  syslog_delegate->set_upload_allowed(true);
+
+  InitTestCase(syslog_delegate.Pass());
 
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
   // Do not retry two times consequentially.
-  RunPendingUploadTaskAndCheckNext(uploader,
-                                   base::TimeDelta::FromMilliseconds(
-                                       SystemLogUploader::kErrorUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
   // We are using the kDefaultUploadDelayMs and not the kErrorUploadDelayMs here
   // because there's just one retry.
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
-  RunPendingUploadTaskAndCheckNext(uploader,
-                                   base::TimeDelta::FromMilliseconds(
-                                       SystemLogUploader::kErrorUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
+  DestroyTestCase();
 }
 
 // Check header fields of system log files to upload.
@@ -203,15 +244,47 @@ TEST_F(SystemLogUploaderTest, CheckHeaders) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles();
-  SystemLogUploader uploader(
-      make_scoped_ptr(new MockSystemLogDelegate(false, system_logs)),
-      task_runner_);
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(false, system_logs));
+  syslog_delegate->set_upload_allowed(true);
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
 
   EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
 
-  RunPendingUploadTaskAndCheckNext(
-      uploader, base::TimeDelta::FromMilliseconds(
-                    SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
+}
+
+// Disable system log uploads after one failed log upload.
+TEST_F(SystemLogUploaderTest, DisableLogUpload) {
+  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+
+  scoped_ptr<MockSystemLogDelegate> syslog_delegate(
+      new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
+  MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
+  InitTestCase(syslog_delegate.Pass());
+
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, true);
+  mock_delegate->set_upload_allowed(true);
+
+  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kErrorUploadDelayMs));
+
+  // Disable log upload and check that frequency is usual, because there is no
+  // errors, we should not upload logs.
+  settings_helper_.SetBoolean(chromeos::kLogUploadEnabled, false);
+  mock_delegate->set_upload_allowed(false);
+  task_runner_->RunPendingTasks();
+
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  RunPendingUploadTaskAndCheckNext(base::TimeDelta::FromMilliseconds(
+      SystemLogUploader::kDefaultUploadDelayMs));
+  DestroyTestCase();
 }
 
 }  // namespace policy