GetTimeToCallback() returns estimated time to callback.

BUG=none
TEST=unit tests

Review-Url: https://codereview.chromium.org/2557663002
Cr-Commit-Position: refs/heads/master@{#439174}

base/timer/timer.cc

@@ -107,6 +107,12 @@ TimeDelta Timer::GetCurrentDelay() const {
   return delay_;
 }
 
+TimeDelta Timer::GetTimeToCallback() const {
+  if (!user_task_)
+    return TimeDelta::Max();
+  return scheduled_run_time_ - Now();
+}
+
 void Timer::SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner) {
   // Do not allow changing the task runner once something has been scheduled.
   DCHECK_EQ(thread_id_, 0);

base/timer/timer.h

@@ -100,6 +100,11 @@ class BASE_EXPORT Timer {
   // Returns the current delay for this timer.
   virtual TimeDelta GetCurrentDelay() const;
 
+  // Returns an estimated time to the timer calling the user_task_ back.
+  // Note that the time may be negative if the timer has not been started,
+  // is late to call back or has done its last call back.
+  virtual TimeDelta GetTimeToCallback() const;
+
   // Set the task runner on which the task should be scheduled. This method can
   // only be called before any tasks have been scheduled. The task runner must
   // run tasks on the same thread the timer is used on.

base/timer/timer_unittest.cc

@@ -623,6 +623,75 @@ TEST(TimerTest, RetainNonRepeatIsRunning) {
   EXPECT_TRUE(timer.IsRunning());
 }
 
+//-----------------------------------------------------------------------------
+
+TEST(TimerTest, RetainRepeatGetTimeToCallback) {
+  scoped_refptr<TestMockTimeTaskRunner> task_runner(
+      new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
+  std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock());
+  MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Timer timer(true, true, tick_clock.get());
+  timer.Start(FROM_HERE, TimeDelta::FromSeconds(2), Bind(&TimerTestCallback));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(2));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+  timer.Stop();
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(2));
+  EXPECT_EQ(TimeDelta::FromSeconds(0), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(2));
+  EXPECT_EQ(TimeDelta::FromSeconds(-2), timer.GetTimeToCallback());
+}
+
+TEST(TimerTest, RetainNonRepeatGetTimeToCallback) {
+  scoped_refptr<TestMockTimeTaskRunner> task_runner(
+      new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
+  std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock());
+  MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Timer timer(true, false, tick_clock.get());
+  timer.Start(FROM_HERE, TimeDelta::FromSeconds(2), Bind(&TimerTestCallback));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(3));
+  EXPECT_EQ(TimeDelta::FromSeconds(-1), timer.GetTimeToCallback());
+}
+
+TEST(TimerTest, OneShotTimerWithTickClockGetTimeToCallback) {
+  scoped_refptr<TestMockTimeTaskRunner> task_runner(
+      new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
+  std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock());
+  MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Receiver receiver;
+  OneShotTimer timer(tick_clock.get());
+  EXPECT_EQ(TimeDelta::Max(), timer.GetTimeToCallback());
+  timer.Start(FROM_HERE, TimeDelta::FromSeconds(2),
+              Bind(&Receiver::OnCalled, Unretained(&receiver)));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
+  EXPECT_EQ(TimeDelta::FromSeconds(1), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(receiver.WasCalled());
+  EXPECT_EQ(TimeDelta::Max(), timer.GetTimeToCallback());
+}
+
+TEST(TimerTest, RepeatingTimerWithTickClockTimeToCallback) {
+  scoped_refptr<TestMockTimeTaskRunner> task_runner(
+      new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now()));
+  std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock());
+  MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Receiver receiver;
+  RepeatingTimer timer(tick_clock.get());
+  timer.Start(FROM_HERE, TimeDelta::FromSeconds(2),
+              Bind(&Receiver::OnCalled, Unretained(&receiver)));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
+  EXPECT_EQ(TimeDelta::FromSeconds(1), timer.GetTimeToCallback());
+  task_runner->FastForwardBy(TimeDelta::FromSeconds(1));
+  EXPECT_EQ(TimeDelta::FromSeconds(2), timer.GetTimeToCallback());
+}
+
 namespace {
 
 bool g_callback_happened1 = false;