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

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 140 matching lines @@
   }
 
   void TearDown() override {
     settings_helper_.RestoreProvider();
     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());
+    EXPECT_TRUE(task_runner_->HasPendingTask());
     task_runner_->RunPendingTasks();
 
     // The previous task should have uploaded another log upload task.
     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();
     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);
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 };
 
 // Check disabled system log uploads by default.
 TEST_F(SystemLogUploaderTest, Basic) {
-  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   std::unique_ptr<MockSystemLogDelegate> syslog_delegate(
       new MockSystemLogDelegate(false, SystemLogUploader::SystemLogs()));
   syslog_delegate->set_upload_allowed(false);
   SystemLogUploader uploader(std::move(syslog_delegate), task_runner_);
 
   task_runner_->RunPendingTasks();
 }
 
 // One success task pending.
 TEST_F(SystemLogUploaderTest, SuccessTest) {
-  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   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_->NumPendingTasks());
 
   RunPendingUploadTaskAndCheckNext(
       uploader, base::TimeDelta::FromMilliseconds(
                     SystemLogUploader::kDefaultUploadDelayMs));
 }
 
 // Three failed responses recieved.
 TEST_F(SystemLogUploaderTest, ThreeFailureTest) {
-  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   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_->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());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   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_->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());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   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_->NumPendingTasks());
   RunPendingUploadTaskAndCheckNext(uploader,
@@ skipping 37 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