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

chrome/browser/chromeos/policy/heartbeat_scheduler_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/heartbeat_scheduler.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 150 matching lines @@
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 
   // The HeartbeatScheduler instance under test.
   policy::HeartbeatScheduler scheduler_;
 };
 
 TEST_F(HeartbeatSchedulerTest, Basic) {
   // Just makes sure we can spin up and shutdown the scheduler with
   // heartbeats disabled.
   settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, false);
-  ASSERT_TRUE(task_runner_->GetPendingTasks().empty());
+  ASSERT_FALSE(task_runner_->HasPendingTask());
 }
 
 TEST_F(HeartbeatSchedulerTest, PermanentlyFailedGCMRegistration) {
   // If heartbeats are enabled, we should register with GCMDriver.
   EXPECT_CALL(gcm_driver_, RegisterImpl(kHeartbeatGCMAppID, _));
   settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, true);
   gcm_driver_.CompleteRegistration(
       kHeartbeatGCMAppID, gcm::GCMClient::GCM_DISABLED);
 
   // There should be no heartbeat tasks pending, because registration failed.
-  ASSERT_TRUE(task_runner_->GetPendingTasks().empty());
+  ASSERT_FALSE(task_runner_->HasPendingTask());
 }
 
 TEST_F(HeartbeatSchedulerTest, TemporarilyFailedGCMRegistration) {
   IgnoreUpstreamNotificationMsg();
 
   EXPECT_CALL(gcm_driver_, RegisterImpl(kHeartbeatGCMAppID, _));
   settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, true);
   gcm_driver_.CompleteRegistration(
       kHeartbeatGCMAppID, gcm::GCMClient::SERVER_ERROR);
   testing::Mock::VerifyAndClearExpectations(&gcm_driver_);
 
   IgnoreUpstreamNotificationMsg();
   gcm_driver_.IgnoreDefaultHeartbeatsInterval();
 
   // Should have a pending task to try registering again.
-  ASSERT_FALSE(task_runner_->GetPendingTasks().empty());
+  ASSERT_TRUE(task_runner_->HasPendingTask());
   EXPECT_CALL(gcm_driver_, RegisterImpl(kHeartbeatGCMAppID, _));
   task_runner_->RunPendingTasks();
   testing::Mock::VerifyAndClearExpectations(&gcm_driver_);
 
   IgnoreUpstreamNotificationMsg();
   gcm_driver_.IgnoreDefaultHeartbeatsInterval();
 
   // Once we have successfully registered, we should send a heartbeat.
   EXPECT_CALL(gcm_driver_, SendImpl(kHeartbeatGCMAppID, _, IsHeartbeatMsg()));
   gcm_driver_.CompleteRegistration(
@@ skipping 18 matching lines @@
   gcm_driver_.IgnoreDefaultHeartbeatsInterval();
 
   const int new_delay = 1234*1000;  // 1234 seconds.
   EXPECT_CALL(gcm_driver_, AddHeartbeatInterval(_, new_delay));
   settings_helper_.SetInteger(chromeos::kHeartbeatFrequency, new_delay);
   // Now run pending heartbeat task, should send a heartbeat.
   gcm::OutgoingMessage message;
   EXPECT_CALL(gcm_driver_, SendImpl(kHeartbeatGCMAppID, _, IsHeartbeatMsg()))
       .WillOnce(SaveArg<2>(&message));
   task_runner_->RunPendingTasks();
-  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 
   // Complete sending a message - we should queue up the next heartbeat
   // even if the previous attempt failed.
   gcm_driver_.CompleteSend(
       kHeartbeatGCMAppID, message.id, gcm::GCMClient::SERVER_ERROR);
   EXPECT_EQ(1U, task_runner_->NumPendingTasks());
   CheckPendingTaskDelay(scheduler_.last_heartbeat(),
                         base::TimeDelta::FromMilliseconds(new_delay));
 }
 
@@ skipping 23 matching lines @@
       base::TimeDelta::FromMilliseconds(
           policy::HeartbeatScheduler::kDefaultHeartbeatIntervalMs));
   testing::Mock::VerifyAndClearExpectations(&gcm_driver_);
 
   IgnoreUpstreamNotificationMsg();
   gcm_driver_.IgnoreDefaultHeartbeatsInterval();
 
   // Now disable heartbeats. Should get no more heartbeats sent.
   settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, false);
   task_runner_->RunPendingTasks();
-  EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
+  EXPECT_FALSE(task_runner_->HasPendingTask());
 }
 
 TEST_F(HeartbeatSchedulerTest, CheckMessageContents) {
   IgnoreUpstreamNotificationMsg();
 
   gcm::OutgoingMessage message;
   EXPECT_CALL(gcm_driver_, RegisterImpl(kHeartbeatGCMAppID, _));
   EXPECT_CALL(gcm_driver_, SendImpl(kHeartbeatGCMAppID, _, IsHeartbeatMsg()))
       .WillOnce(SaveArg<2>(&message));
   settings_helper_.SetBoolean(chromeos::kHeartbeatEnabled, true);
@@ skipping 58 matching lines @@
 
   EXPECT_CALL(gcm_driver_,
               SendImpl(kHeartbeatGCMAppID, _, IsUpstreamNotificationMsg()))
       .Times(AtLeast(1));
   gcm_driver_.CompleteRegistration(kHeartbeatGCMAppID, gcm::GCMClient::SUCCESS);
 
   gcm_driver_.NotifyConnected();
 }
 
 }  // namespace