Replaces instances of the deprecated TimeTicks::HighResNow() with TimeTicks::Now().

base/message_loop/message_pump_perftest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
@@ skipping 11 matching lines @@
 namespace base {
 namespace {
 
 class ScheduleWorkTest : public testing::Test {
  public:
   ScheduleWorkTest() : counter_(0) {}
 
   void Increment(uint64_t amount) { counter_ += amount; }
 
   void Schedule(int index) {
-    base::TimeTicks start = base::TimeTicks::HighResNow();
+    base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks thread_start;
     if (TimeTicks::IsThreadNowSupported())
       thread_start = base::TimeTicks::ThreadNow();
     base::TimeDelta minimum = base::TimeDelta::Max();
     base::TimeDelta maximum = base::TimeDelta();
     base::TimeTicks now, lastnow = start;
     uint64_t schedule_calls = 0u;
     do {
       for (size_t i = 0; i < kBatchSize; ++i) {
         target_message_loop()->ScheduleWork();
         schedule_calls++;
       }
-      now = base::TimeTicks::HighResNow();
+      now = base::TimeTicks::Now();
       base::TimeDelta laptime = now - lastnow;
       lastnow = now;
       minimum = std::min(minimum, laptime);
       maximum = std::max(maximum, laptime);
     } while (now - start < base::TimeDelta::FromSeconds(kTargetTimeSec));
 
     scheduling_times_[index] = now - start;
     if (TimeTicks::IsThreadNowSupported())
       scheduling_thread_times_[index] =
           base::TimeTicks::ThreadNow() - thread_start;
@@ skipping 179 matching lines @@
   void Run(Delegate* delegate) override {}
 
   void Quit() override {}
   void ScheduleWork() override {}
   void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override {}
 };
 
 class PostTaskTest : public testing::Test {
  public:
   void Run(int batch_size, int tasks_per_reload) {
-    base::TimeTicks start = base::TimeTicks::HighResNow();
+    base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks now;
     MessageLoop loop(scoped_ptr<MessagePump>(new FakeMessagePump));
     scoped_refptr<internal::IncomingTaskQueue> queue(
         new internal::IncomingTaskQueue(&loop));
     uint32_t num_posted = 0;
     do {
       for (int i = 0; i < batch_size; ++i) {
         for (int j = 0; j < tasks_per_reload; ++j) {
           queue->AddToIncomingQueue(
               FROM_HERE, base::Bind(&DoNothing), base::TimeDelta(), false);
           num_posted++;
         }
         TaskQueue loop_local_queue;
         queue->ReloadWorkQueue(&loop_local_queue);
         while (!loop_local_queue.empty()) {
           PendingTask t = loop_local_queue.front();
           loop_local_queue.pop();
           loop.RunTask(t);
         }
       }
 
-      now = base::TimeTicks::HighResNow();
+      now = base::TimeTicks::Now();
     } while (now - start < base::TimeDelta::FromSeconds(5));
     std::string trace = StringPrintf("%d_tasks_per_reload", tasks_per_reload);
     perf_test::PrintResult(
         "task",
         "",
         trace,
         (now - start).InMicroseconds() / static_cast<double>(num_posted),
         "us/task",
         true);
   }
 };
 
 TEST_F(PostTaskTest, OneTaskPerReload) {
   Run(10000, 1);
 }
 
 TEST_F(PostTaskTest, TenTasksPerReload) {
   Run(10000, 10);
 }
 
 TEST_F(PostTaskTest, OneHundredTasksPerReload) {
   Run(1000, 100);
 }
 
 }  // namespace
 }  // namespace base