Make TestSimpleTaskRunner thread-safe.

chrome/browser/chromeos/policy/system_log_uploader_unittest.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 "chrome/browser/chromeos/policy/system_log_uploader.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 144 matching lines @@
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   // Given a pending task to upload system logs.
   void RunPendingUploadTaskAndCheckNext(const SystemLogUploader& uploader,
                                         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());
+    EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
     CheckPendingTaskDelay(uploader, expected_delay);
   }
 
   void CheckPendingTaskDelay(const SystemLogUploader& uploader,
                              base::TimeDelta expected_delay) {
     // The next task should be scheduled sometime between
     // |last_upload_attempt| + |expected_delay| and
     // |now| + |expected_delay|.
     base::Time now = base::Time::NowFromSystemTime();
@@ skipping 24 matching lines @@
 // One success task pending.
 TEST_F(SystemLogUploaderTest, SuccessTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
 }
 
 // Three failed responses recieved.
 TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
   // Do not retry two times consequentially.
   RunPendingUploadTaskAndCheckNext(uploader,
                                    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));
 }
 
 // Check header fields of system log files to upload.
 TEST_F(SystemLogUploaderTest, CheckHeaders) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   SystemLogUploader::SystemLogs system_logs = GenerateTestSystemLogFiles();
   std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, system_logs));
   syslog_delegate->set_upload_allowed(true);
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
 }
 
 // Disable system log uploads after one failed log upload.
 TEST_F(SystemLogUploaderTest, DisableLogUpload) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
   std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(true, SystemLogUploader::SystemLogs()));
   MockSystemLogDelegate* mock_delegate = syslog_delegate.get();
   settings_helper_.SetBoolean(chromeos::kSystemLogUploadEnabled, true);
   mock_delegate->set_upload_allowed(true);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
   RunPendingUploadTaskAndCheckNext(uploader,
                                    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::kSystemLogUploadEnabled, false);
   mock_delegate->set_upload_allowed(false);
   task_runner_->RunPendingTasks();
 
@@ skipping 28 matching lines @@
       "<IPv4: 1>55\n"
       "aaaa<IPv4: 2>aaa\n"
       "11:11;<IPv6: 1>\n"
       "<IPv6: 1>\n"
       "11:11:abcdef:0:0:0:0:0\n"
       "aa:aa:aa:00:00:01";
   EXPECT_EQ(result, SystemLogUploader::RemoveSensitiveData(&anonymizer, data));
 }
 
 }  // namespace policy