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

base/time/time_unittest.cc

 // Copyright (c) 2012 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/time/time.h"
 
 #include <time.h>
 
 #include <limits>
 #include <string>
@@ skipping 625 matching lines @@
     // Unfortunately, our InMilliseconds() function truncates
     // rather than rounds.  We should consider fixing this
     // so that our averages come out better.
     EXPECT_GE(delta.InMilliseconds(), 9);
     EXPECT_GE(delta.InMicroseconds(), 9000);
     EXPECT_EQ(delta.InSeconds(), 0);
   }
 }
 
 static void HighResClockTest(TimeTicks (*GetTicks)()) {
-  // HighResNow doesn't work on some systems.  Since the product still works
-  // even if it doesn't work, it makes this entire test questionable.
+  // IsHighResolution() is false on some systems.  Since the product still works
+  // even if it's false, it makes this entire test questionable.
   if (!TimeTicks::IsHighResolution())
     return;
 
   // Why do we loop here?
   // We're trying to measure that intervals increment in a VERY small amount
   // of time --  less than 15ms.  Unfortunately, if we happen to have a
   // context switch in the middle of our test, the context switch could easily
   // exceed our limit.  So, we iterate on this several times.  As long as we're
   // able to detect the fine-granularity timers at least once, then the test
   // has succeeded.
@@ skipping 14 matching lines @@
 
     if (delta.InMicroseconds() <= kTargetGranularityUs)
       success = true;
   }
 
   // In high resolution mode, we expect to see the clock increment
   // in intervals less than 15ms.
   EXPECT_TRUE(success);
 }
 
-TEST(TimeTicks, HighResNow) {
-  HighResClockTest(&TimeTicks::HighResNow);
+TEST(TimeTicks, HighRes) {
+  HighResClockTest(&TimeTicks::Now);
 }
 
 // Fails frequently on Android http://crbug.com/352633 with:
 // Expected: (delta_thread.InMicroseconds()) > (0), actual: 0 vs 0
 #if defined(OS_ANDROID)
 #define MAYBE_ThreadNow DISABLED_ThreadNow
 #else
 #define MAYBE_ThreadNow ThreadNow
 #endif
 TEST(TimeTicks, MAYBE_ThreadNow) {
@@ skipping 10 matching lines @@
     TimeDelta delta_thread = end_thread - begin_thread;
     // Make sure that some thread time have elapsed.
     EXPECT_GT(delta_thread.InMicroseconds(), 0);
     // But the thread time is at least 9ms less than clock time.
     TimeDelta difference = delta - delta_thread;
     EXPECT_GE(difference.InMicroseconds(), 9000);
   }
 }
 
 TEST(TimeTicks, NowFromSystemTraceTime) {
-  // Re-use HighResNow test for now since clock properties are identical.
+  // Re-use HighRes test for now since clock properties are identical.
   HighResClockTest(&TimeTicks::NowFromSystemTraceTime);
 }
 
 TEST(TimeDelta, FromAndIn) {
   EXPECT_TRUE(TimeDelta::FromDays(2) == TimeDelta::FromHours(48));
   EXPECT_TRUE(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180));
   EXPECT_TRUE(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120));
   EXPECT_TRUE(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000));
   EXPECT_TRUE(TimeDelta::FromMilliseconds(2) ==
               TimeDelta::FromMicroseconds(2000));
@@ skipping 166 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base