Use TestSimpleTaskRunner::HasPendingTask instead of GetPendingTasks().empty()

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 88 matching lines @@
 
   void TearDown() override {
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   // Given a pending task to upload status, mocks out a server response.
   void RunPendingUploadTaskAndCheckNext(const StatusUploader& uploader,
                                         base::TimeDelta expected_delay) {
     // Running the task should pass two callbacks into GetDeviceStatusAsync
     // and GetDeviceSessionStatusAsync. We'll grab these two callbacks.
-    EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+    EXPECT_TRUE(task_runner_->HasPendingTask());
     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_);
 
     // Send some "valid" (read: non-nullptr) to the device/session callbacks
     // in order to simulate valid status data.
     std::unique_ptr<em::DeviceStatusReportRequest> device_status =
         base::MakeUnique<em::DeviceStatusReportRequest>();
     std::unique_ptr<em::SessionStatusReportRequest> session_status =
         base::MakeUnique<em::SessionStatusReportRequest>();
 
     // Running the session and device callbacks should trigger
     // CloudPolicyClient::UploadDeviceStatus.
     CloudPolicyClient::StatusCallback callback;
     EXPECT_CALL(client_, UploadDeviceStatus(_, _, _))
         .WillOnce(SaveArg<2>(&callback));
     ds_callback.Run(std::move(device_status));
     ss_callback.Run(std::move(session_status));
     testing::Mock::VerifyAndClearExpectations(&device_management_service_);
 
     // Make sure no status upload is queued up yet (since an upload is in
     // progress).
-    EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+    EXPECT_FALSE(task_runner_->HasPendingTask());
 
     // 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_->NumPendingTasks());
 
     CheckPendingTaskDelay(uploader, expected_delay);
   }
@@ skipping 14 matching lines @@
   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());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
   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());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
   StatusUploader uploader(&client_, std::move(collector_), task_runner_);
   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);
 }
 
@@ skipping 89 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