Make base::TimeTicks::NowTicks const.

The operation ("what time is it?") is conceptually const, so make the
method so. Implementations that mutate their state now have such state
expliclty marked as mutable.

This change was inspired by review comments on product code that uses a
TickClock for the sake of testability, in which the reviewers wondered
why a TickClock* class member was not const. Prior to this change, the
answer was "because it can't be". Following this change, the answer can
be "because I forgot to do that. Thanks!"

BUG=none

Change-Id: I813c5359b143c52d86306200ef50eeac4a0003d1
Reviewed-on: https://chromium-review.googlesource.com/980052Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Commit-Queue: Greg Thompson <grt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#545944}

base/test/simple_test_tick_clock.cc

@@ -12,7 +12,7 @@ SimpleTestTickClock::SimpleTestTickClock() = default;
 
 SimpleTestTickClock::~SimpleTestTickClock() = default;
 
-TimeTicks SimpleTestTickClock::NowTicks() {
+TimeTicks SimpleTestTickClock::NowTicks() const {
   AutoLock lock(lock_);
   return now_ticks_;
 }

base/test/simple_test_tick_clock.h

@@ -21,7 +21,7 @@ class SimpleTestTickClock : public TickClock {
   SimpleTestTickClock();
   ~SimpleTestTickClock() override;
 
-  TimeTicks NowTicks() override;
+  TimeTicks NowTicks() const override;
 
   // Advances the clock by |delta|, which must not be negative.
   void Advance(TimeDelta delta);
@@ -31,7 +31,7 @@ class SimpleTestTickClock : public TickClock {
 
  private:
   // Protects |now_ticks_|.
-  Lock lock_;
+  mutable Lock lock_;
 
   TimeTicks now_ticks_;
 };

base/test/test_mock_time_task_runner.cc

@@ -27,7 +27,7 @@ class LegacyMockTickClock : public TickClock {
       : task_runner_(std::move(task_runner)) {}
 
   // TickClock:
-  TimeTicks NowTicks() override { return task_runner_->NowTicks(); }
+  TimeTicks NowTicks() const override { return task_runner_->NowTicks(); }
 
  private:
   scoped_refptr<const TestMockTimeTaskRunner> task_runner_;
@@ -413,7 +413,7 @@ void TestMockTimeTaskRunner::EnsureWorkScheduled() {
   // doesn't need an extra kick on nested runs.
 }
 
-TimeTicks TestMockTimeTaskRunner::MockClock::NowTicks() {
+TimeTicks TestMockTimeTaskRunner::MockClock::NowTicks() const {
   return task_runner_->NowTicks();
 }
 

base/test/test_mock_time_task_runner.h

@@ -209,7 +209,7 @@ class TestMockTimeTaskRunner : public SingleThreadTaskRunner,
         : task_runner_(task_runner) {}
 
     // TickClock:
-    TimeTicks NowTicks() override;
+    TimeTicks NowTicks() const override;
 
     // Clock:
     Time Now() override;

base/time/default_tick_clock.cc

@@ -10,7 +10,7 @@ namespace base {
 
 DefaultTickClock::~DefaultTickClock() = default;
 
-TimeTicks DefaultTickClock::NowTicks() {
+TimeTicks DefaultTickClock::NowTicks() const {
   return TimeTicks::Now();
 }
 

base/time/default_tick_clock.h

@@ -17,7 +17,7 @@ class BASE_EXPORT DefaultTickClock : public TickClock {
   ~DefaultTickClock() override;
 
   // Simply returns TimeTicks::Now().
-  TimeTicks NowTicks() override;
+  TimeTicks NowTicks() const override;
 
   // Returns a shared instance of DefaultTickClock. This is thread-safe.
   static DefaultTickClock* GetInstance();

base/time/tick_clock.h

@@ -32,7 +32,7 @@ class BASE_EXPORT TickClock {
   // assume that NowTicks() is monotonic (but not strictly monotonic).
   // In other words, the returned TimeTicks will never decrease with
   // time, although they might "stand still".
-  virtual TimeTicks NowTicks() = 0;
+  virtual TimeTicks NowTicks() const = 0;
 };
 
 }  // namespace base

chrome/browser/android/data_usage/tab_data_use_entry_unittest.cc

@@ -41,7 +41,7 @@ class SimpleOffsetTestTickClock : public base::TickClock {
   ~SimpleOffsetTestTickClock() override {}
 
   // Returns the spoofed time as Now.
-  base::TimeTicks NowTicks() override {
+  base::TimeTicks NowTicks() const override {
     return base::TimeTicks::UnixEpoch() + now_offset_;
   }
 

chrome/browser/chromeos/net/network_portal_detector_impl.cc

@@ -417,7 +417,7 @@ base::TimeTicks NetworkPortalDetectorImpl::AttemptStartTime() {
   return attempt_start_time_;
 }
 
-base::TimeTicks NetworkPortalDetectorImpl::NowTicks() {
+base::TimeTicks NetworkPortalDetectorImpl::NowTicks() const {
   if (time_ticks_for_testing_.is_null())
     return base::TimeTicks::Now();
   return time_ticks_for_testing_;

chrome/browser/chromeos/net/network_portal_detector_impl.h

@@ -140,7 +140,7 @@ class NetworkPortalDetectorImpl : public NetworkPortalDetector,
   // PortalDetectorStrategy::Delegate implementation:
   int NoResponseResultCount() override;
   base::TimeTicks AttemptStartTime() override;
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
 
   // content::NotificationObserver implementation:
   void Observe(int type,

chrome/browser/chromeos/night_light/night_light_client_unittest.cc

@@ -75,7 +75,7 @@ class FakeNightLightClient : public NightLightClient,
   base::Time Now() override { return fake_now_; }
 
   // base::TickClock:
-  base::TimeTicks NowTicks() override { return fake_now_ticks_; }
+  base::TimeTicks NowTicks() const override { return fake_now_ticks_; }
 
   void set_fake_now(base::Time now) { fake_now_ = now; }
   void set_fake_now_ticks(base::TimeTicks now_ticks) {

components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc

@@ -194,7 +194,7 @@ TestDataReductionProxyConfigServiceClient::TestTickClock::TestTickClock(
 }
 
 base::TimeTicks
-TestDataReductionProxyConfigServiceClient::TestTickClock::NowTicks() {
+TestDataReductionProxyConfigServiceClient::TestTickClock::NowTicks() const {
   return base::TimeTicks::UnixEpoch() + (time_ - base::Time::UnixEpoch());
 }
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h

@@ -152,7 +152,7 @@ class TestDataReductionProxyConfigServiceClient
     TestTickClock(const base::Time& initial_time);
 
     // base::TickClock implementation.
-    base::TimeTicks NowTicks() override;
+    base::TimeTicks NowTicks() const override;
 
     // base::Clock implementation.
     base::Time Now() override;

components/domain_reliability/test_util.cc

@@ -122,7 +122,9 @@ MockTime::MockTime()
 MockTime::~MockTime() {}
 
 base::Time MockTime::Now() { return now_; }
-base::TimeTicks MockTime::NowTicks() { return now_ticks_; }
+base::TimeTicks MockTime::NowTicks() const {
+  return now_ticks_;
+}
 
 std::unique_ptr<MockableTime::Timer> MockTime::CreateTimer() {
   return std::unique_ptr<MockableTime::Timer>(new MockTimer(this));

components/domain_reliability/test_util.h

@@ -76,7 +76,7 @@ class MockTime : public MockableTime {
 
   // MockableTime implementation:
   base::Time Now() override;
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
   std::unique_ptr<MockableTime::Timer> CreateTimer() override;
 
   // Pretends that |delta| has passed, and runs tasks that would've happened

components/domain_reliability/util.cc

@@ -242,7 +242,9 @@ ActualTime::ActualTime() {}
 ActualTime::~ActualTime() {}
 
 base::Time ActualTime::Now() { return base::Time::Now(); }
-base::TimeTicks ActualTime::NowTicks() { return base::TimeTicks::Now(); }
+base::TimeTicks ActualTime::NowTicks() const {
+  return base::TimeTicks::Now();
+}
 
 std::unique_ptr<MockableTime::Timer> ActualTime::CreateTimer() {
   return std::unique_ptr<MockableTime::Timer>(new ActualTimer());

components/domain_reliability/util.h

@@ -84,7 +84,7 @@ class DOMAIN_RELIABILITY_EXPORT MockableTime : public base::Clock,
   // Clock impl; returns base::Time::Now() or a mocked version thereof.
   base::Time Now() override = 0;
   // TickClock impl; returns base::TimeTicks::Now() or a mocked version thereof.
-  base::TimeTicks NowTicks() override = 0;
+  base::TimeTicks NowTicks() const override = 0;
 
   // Returns a new Timer, or a mocked version thereof.
   virtual std::unique_ptr<MockableTime::Timer> CreateTimer() = 0;
@@ -106,7 +106,7 @@ class DOMAIN_RELIABILITY_EXPORT ActualTime : public MockableTime {
 
   // MockableTime implementation:
   base::Time Now() override;
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
   std::unique_ptr<MockableTime::Timer> CreateTimer() override;
 };
 

content/browser/indexed_db/indexed_db_tombstone_sweeper_unittest.cc

@@ -66,7 +66,7 @@ class MockTickClock : public base::TickClock {
   MockTickClock() {}
   ~MockTickClock() override {}
 
-  MOCK_METHOD0(NowTicks, base::TimeTicks());
+  MOCK_CONST_METHOD0(NowTicks, base::TimeTicks());
 };
 
 class Comparator : public LevelDBComparator {

extensions/browser/extension_throttle_test_support.cc

@@ -15,7 +15,7 @@ TestTickClock::TestTickClock(base::TimeTicks now) : now_ticks_(now) {
 TestTickClock::~TestTickClock() {
 }
 
-base::TimeTicks TestTickClock::NowTicks() {
+base::TimeTicks TestTickClock::NowTicks() const {
   return now_ticks_;
 }
 

extensions/browser/extension_throttle_test_support.h

@@ -20,7 +20,7 @@ class TestTickClock : public base::TickClock {
   explicit TestTickClock(base::TimeTicks now);
   ~TestTickClock() override;
 
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
   void set_now(base::TimeTicks now) { now_ticks_ = now; }
 
  private:

media/cast/test/skewed_tick_clock.cc

@@ -17,7 +17,7 @@ SkewedTickClock::SkewedTickClock(base::TickClock* clock)
       skew_clock_at_last_set_(last_skew_set_time_) {
 }
 
-base::TimeTicks SkewedTickClock::SkewTicks(base::TimeTicks now) {
+base::TimeTicks SkewedTickClock::SkewTicks(base::TimeTicks now) const {
   return base::TimeDelta::FromMicroseconds(
       (now - last_skew_set_time_).InMicroseconds() * skew_) +
       skew_clock_at_last_set_;
@@ -30,7 +30,7 @@ void SkewedTickClock::SetSkew(double skew, base::TimeDelta offset) {
   last_skew_set_time_ = now;
 }
 
-base::TimeTicks SkewedTickClock::NowTicks() {
+base::TimeTicks SkewedTickClock::NowTicks() const {
   return SkewTicks(clock_->NowTicks());
 }
 

media/cast/test/skewed_tick_clock.h

@@ -26,10 +26,10 @@ class SkewedTickClock : public base::TickClock {
   // jump forwards or backwards, only changing the offset will
   // do that.
   void SetSkew(double skew, base::TimeDelta offset);
-  base::TimeTicks NowTicks() final;
+  base::TimeTicks NowTicks() const final;
 
  private:
-  base::TimeTicks SkewTicks(base::TimeTicks now);
+  base::TimeTicks SkewTicks(base::TimeTicks now) const;
   base::TickClock* clock_;  // Not owned.
   double skew_;
   base::TimeTicks last_skew_set_time_;

media/test/pipeline_integration_test_base.cc

@@ -680,7 +680,7 @@ void PipelineIntegrationTestBase::RunUntilIdleEndedOrErrorInternal(
   scoped_task_environment_.RunUntilIdle();
 }
 
-base::TimeTicks DummyTickClock::NowTicks() {
+base::TimeTicks DummyTickClock::NowTicks() const {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }

media/test/pipeline_integration_test_base.h

@@ -49,10 +49,10 @@ class DummyTickClock : public base::TickClock {
  public:
   DummyTickClock() : now_() {}
   ~DummyTickClock() override {}
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
 
  private:
-  base::TimeTicks now_;
+  mutable base::TimeTicks now_;
 };
 
 class PipelineTestRendererFactory {

net/base/backoff_entry_serializer_unittest.cc

@@ -34,7 +34,7 @@ class TestTickClock : public base::TickClock {
   TestTickClock() = default;
   ~TestTickClock() override = default;
 
-  TimeTicks NowTicks() override { return now_ticks_; }
+  TimeTicks NowTicks() const override { return now_ticks_; }
   void set_now(TimeTicks now) { now_ticks_ = now; }
 
  private:

net/base/backoff_entry_unittest.cc

@@ -22,7 +22,7 @@ class TestTickClock : public base::TickClock {
   TestTickClock() = default;
   ~TestTickClock() override = default;
 
-  TimeTicks NowTicks() override { return now_ticks_; }
+  TimeTicks NowTicks() const override { return now_ticks_; }
   void set_now(TimeTicks now) { now_ticks_ = now; }
 
  private:

net/url_request/url_request_throttler_test_support.cc

@@ -14,7 +14,7 @@ TestTickClock::TestTickClock(base::TimeTicks now) : now_ticks_(now) {}
 
 TestTickClock::~TestTickClock() = default;
 
-base::TimeTicks TestTickClock::NowTicks() {
+base::TimeTicks TestTickClock::NowTicks() const {
   return now_ticks_;
 }
 

net/url_request/url_request_throttler_test_support.h

@@ -20,7 +20,7 @@ class TestTickClock : public base::TickClock {
   explicit TestTickClock(base::TimeTicks now);
   ~TestTickClock() override;
 
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
   void set_now(base::TimeTicks now) { now_ticks_ = now; }
 
  private:

services/resource_coordinator/observers/page_signal_generator_impl_unittest.cc

@@ -28,7 +28,7 @@ class TickClockWrapper : public base::TickClock {
   ~TickClockWrapper() override {}
 
   // base::TickClock implementation:
-  base::TimeTicks NowTicks() override { return tick_clock_->NowTicks(); }
+  base::TimeTicks NowTicks() const override { return tick_clock_->NowTicks(); }
 
  private:
   base::TickClock* tick_clock_;

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.cc

@@ -57,7 +57,7 @@ void TaskQueueManagerDelegateForTest::AddNestingObserver(
 void TaskQueueManagerDelegateForTest::RemoveNestingObserver(
     base::RunLoop::NestingObserver* observer) {}
 
-base::TimeTicks TaskQueueManagerDelegateForTest::NowTicks() {
+base::TimeTicks TaskQueueManagerDelegateForTest::NowTicks() const {
   return time_source_->NowTicks();
 }
 

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.h

@@ -38,7 +38,7 @@ class TaskQueueManagerDelegateForTest : public TaskQueueManagerDelegate {
   void RemoveNestingObserver(base::RunLoop::NestingObserver* observer) override;
 
   // TickClock:
-  base::TimeTicks NowTicks() override;
+  base::TimeTicks NowTicks() const override;
 
  protected:
   ~TaskQueueManagerDelegateForTest() override;

third_party/WebKit/Source/platform/scheduler/base/test_count_uses_time_source.cc

@@ -12,7 +12,7 @@ TestCountUsesTimeSource::TestCountUsesTimeSource() : now_calls_count_(0) {}
 
 TestCountUsesTimeSource::~TestCountUsesTimeSource() = default;
 
-base::TimeTicks TestCountUsesTimeSource::NowTicks() {
+base::TimeTicks TestCountUsesTimeSource::NowTicks() const {
   now_calls_count_++;
   // Don't return 0, as it triggers some assertions.
   return base::TimeTicks() + base::TimeDelta::FromSeconds(1);

third_party/WebKit/Source/platform/scheduler/base/test_count_uses_time_source.h

@@ -16,13 +16,13 @@ class TestCountUsesTimeSource : public base::TickClock {
   explicit TestCountUsesTimeSource();
   ~TestCountUsesTimeSource() override;
 
-  base::TimeTicks NowTicks() override;
-  int now_calls_count() { return now_calls_count_; }
+  base::TimeTicks NowTicks() const override;
+  int now_calls_count() const { return now_calls_count_; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestCountUsesTimeSource);
 
-  int now_calls_count_;
+  mutable int now_calls_count_;
 };
 
 }  // namespace scheduler

third_party/WebKit/Source/platform/scheduler/common/throttling/task_queue_throttler_unittest.cc

@@ -57,8 +57,8 @@ class AutoAdvancingTestClock : public base::SimpleTestTickClock {
       : advancing_interval_(interval) {}
   ~AutoAdvancingTestClock() override = default;
 
-  base::TimeTicks NowTicks() override {
-    Advance(advancing_interval_);
+  base::TimeTicks NowTicks() const override {
+    const_cast<AutoAdvancingTestClock*>(this)->Advance(advancing_interval_);
     return SimpleTestTickClock::NowTicks();
   }
 

ui/events/test/event_generator.cc

@@ -37,18 +37,21 @@
 namespace ui {
 namespace test {
 
+// A TickClock that advances time by one millisecond on each call to NowTicks().
 class TestTickClock : public base::TickClock {
  public:
-  // Starts off with a clock set to TimeTicks().
-  TestTickClock() {}
-
-  base::TimeTicks NowTicks() override {
-    return base::TimeTicks() +
-           base::TimeDelta::FromMicroseconds(ticks_++ * 1000);
+  TestTickClock() = default;
+
+  // Unconditionally returns a tick count that is 1ms later than the previous
+  // call, starting at 1ms.
+  base::TimeTicks NowTicks() const override {
+    static constexpr base::TimeDelta kOneMillisecond =
+        base::TimeDelta::FromMilliseconds(1);
+    return ticks_ += kOneMillisecond;
   }
 
  private:
-  int64_t ticks_ = 1;
+  mutable base::TimeTicks ticks_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTickClock);
 };