make conversion easier

Author: iskakaushik

fml/time/dart_timestamp_provider.cc

@@ -12,17 +12,20 @@ DartTimestampProvider::DartTimestampProvider() = default;
 
 DartTimestampProvider::~DartTimestampProvider() = default;
 
+int64_t DartTimestampProvider::ConvertToNanos(int64_t ticks,
+                                              int64_t frequency) {
+  int64_t nano_seconds = (ticks / frequency) * kNanosPerSecond;
+  int64_t leftover_ticks = ticks % frequency;
+  int64_t leftover_nanos = (leftover_ticks * kNanosPerSecond) / frequency;
+  return nano_seconds + leftover_nanos;
+}
+
 fml::TimePoint DartTimestampProvider::Now() {
   const int64_t ticks = Dart_TimelineGetTicks();
   const int64_t frequency = Dart_TimelineGetTicksFrequency();
   // optimization for the most common case.
   if (frequency != kNanosPerSecond) {
-    // convert from frequency base to nanos.
-    int64_t seconds = ticks / frequency;
-    int64_t leftover_ticks = ticks - (seconds * frequency);
-    int64_t result = seconds * kNanosPerSecond;
-    result += ((leftover_ticks * kNanosPerSecond) / frequency);
-    return fml::TimePoint::FromTicks(result);
+    return fml::TimePoint::FromTicks(ConvertToNanos(ticks, frequency));
   } else {
     return fml::TimePoint::FromTicks(ticks);
   }

fml/time/dart_timestamp_provider.h

@@ -29,6 +29,8 @@ class DartTimestampProvider : TimestampProvider {
  private:
   static constexpr int64_t kNanosPerSecond = 1000000000;
 
+  int64_t ConvertToNanos(int64_t ticks, int64_t frequency);
+
   DartTimestampProvider();
 
   FML_DISALLOW_COPY_AND_ASSIGN(DartTimestampProvider);

fml/time/time_point.h

@@ -39,6 +39,7 @@ class TimePoint {
     return TimePoint(ticks.ToNanoseconds());
   }
 
+  // Expects ticks in nanos.
   static constexpr TimePoint FromTicks(int64_t ticks) {
     return TimePoint(ticks);
   }

fml/time/time_point_unittest.cc

@@ -26,8 +26,8 @@ TEST(TimePoint, DartClockIsMonotonic) {
   std::this_thread::sleep_for(1us);
   const auto t3 = DartTimelineTicksSinceEpoch();
   EXPECT_LT(TimePoint::Min(), t1);
-  EXPECT_LT(t1, t2);
-  EXPECT_LT(t2, t3);
+  EXPECT_LE(t1, t2);
+  EXPECT_LE(t2, t3);
   EXPECT_LT(t3, TimePoint::Max());
 }