Make TestSimpleTaskRunner thread-safe.

chrome/browser/chromeos/policy/status_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/status_uploader.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 123 matching lines @@
 
     // Make sure no status upload is queued up yet (since an upload is in
     // progress).
     EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 
     // Now invoke the response.
     callback.Run(true);
 
     // Now that the previous request was satisfied, a task to do the next
     // upload should be queued.
-    EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+    EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 
     CheckPendingTaskDelay(uploader, expected_delay);
   }
 
   void CheckPendingTaskDelay(const StatusUploader& uploader,
                              base::TimeDelta expected_delay) {
     // The next task should be scheduled sometime between |last_upload| +
     // |expected_delay| and |now| + |expected_delay|.
     base::Time now = base::Time::NowFromSystemTime();
     base::Time next_task = now + task_runner_->NextPendingTaskDelay();
 
     EXPECT_LE(next_task, now + expected_delay);
     EXPECT_GE(next_task, uploader.last_upload() + expected_delay);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   std::unique_ptr<MockDeviceStatusCollector> collector_;
   MockDeviceStatusCollector* collector_ptr_;
   ui::UserActivityDetector detector_;
   MockCloudPolicyClient client_;
   MockDeviceManagementService device_management_service_;
   TestingPrefServiceSimple prefs_;
 };
 
 TEST_F(StatusUploaderTest, BasicTest) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
   // On startup, first update should happen in 1 minute.
   EXPECT_EQ(base::TimeDelta::FromMinutes(1),
             task_runner_->NextPendingTaskDelay());
 }
 
 TEST_F(StatusUploaderTest, DifferentFrequencyAtStart) {
   const int new_delay = StatusUploader::kDefaultUploadDelayMs * 2;
   settings_helper_.SetInteger(chromeos::kReportUploadFrequency, new_delay);
   const base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(
       new_delay);
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
-  ASSERT_EQ(1U, task_runner_->GetPendingTasks().size());
+  ASSERT_EQ(1U, task_runner_->NumPendingTasks());
   // On startup, first update should happen in 1 minute.
   EXPECT_EQ(base::TimeDelta::FromMinutes(1),
             task_runner_->NextPendingTaskDelay());
 
   // Second update should use the delay specified in settings.
   RunPendingUploadTaskAndCheckNext(uploader, expected_delay);
 }
 
 TEST_F(StatusUploaderTest, ResetTimerAfterStatusCollection) {
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
   const base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(
       StatusUploader::kDefaultUploadDelayMs);
   RunPendingUploadTaskAndCheckNext(uploader, expected_delay);
 
   // Handle this response also, and ensure new task is queued.
   RunPendingUploadTaskAndCheckNext(uploader, expected_delay);
 
   // Now that the previous request was satisfied, a task to do the next
   // upload should be queued again.
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
 }
 
 TEST_F(StatusUploaderTest, ResetTimerAfterFailedStatusCollection) {
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
 
   // Running the queued task should pass two callbacks into GetDeviceStatusAsync
   // and GetDeviceSessionStatusAsync. We'll grab these two callbacks and send
   // nullptrs to them in order to simulate failure to get status.
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());
   DeviceStatusCollector::DeviceStatusCallback ds_callback;
   DeviceStatusCollector::DeviceSessionStatusCallback ss_callback;
   EXPECT_CALL(*collector_ptr_, GetDeviceStatusAsync(_))
       .WillOnce(SaveArg<0>(&ds_callback));
   EXPECT_CALL(*collector_ptr_, GetDeviceSessionStatusAsync(_))
       .WillOnce(SaveArg<0>(&ss_callback));
   task_runner_->RunPendingTasks();
   testing::Mock::VerifyAndClearExpectations(&device_management_service_);
 
   // Running the session and device callbacks should trigger
   // StatusUploader::OnStatusReceived, which in turn should recognize the
   // failure to get status and queue another status upload.
   std::unique_ptr<em::DeviceStatusReportRequest> invalid_device_status;
   ds_callback.Run(std::move(invalid_device_status));
-  EXPECT_EQ(0U, task_runner_->GetPendingTasks().size());  // Not yet...
+  EXPECT_EQ(0U, task_runner_->NumPendingTasks());  // Not yet...
 
   std::unique_ptr<em::SessionStatusReportRequest> invalid_session_status;
   ss_callback.Run(std::move(invalid_session_status));
-  EXPECT_EQ(1U, task_runner_->GetPendingTasks().size());  // but now!
+  EXPECT_EQ(1U, task_runner_->NumPendingTasks());  // but now!
 
   // Check the delay of the queued upload
   const base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(
       StatusUploader::kDefaultUploadDelayMs);
   CheckPendingTaskDelay(uploader, expected_delay);
 }
 
 TEST_F(StatusUploaderTest, ChangeFrequency) {
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
   // Change the frequency. The new frequency should be reflected in the timing
@@ skipping 39 matching lines @@
   // Now mock video capture, and no session data should be allowed.
   MediaCaptureDevicesDispatcher::GetInstance()->OnMediaRequestStateChanged(
       0, 0, 0, GURL("http://www.google.com"),
       content::MEDIA_DEVICE_VIDEO_CAPTURE,
       content::MEDIA_REQUEST_STATE_OPENING);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(uploader.IsSessionDataUploadAllowed());
 }
 
 }  // namespace policy