Revert of Several Tick counter improvements.

webrtc/system_wrappers/include/tick_util.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 38 matching lines @@
   // Now in the time domain in us.
   static int64_t MicrosecondTimestamp();
 
   // Returns the number of ticks in the tick domain.
   int64_t Ticks() const;
 
   static int64_t MillisecondsToTicks(const int64_t ms);
 
   static int64_t TicksToMilliseconds(const int64_t ticks);
 
-  static int64_t TicksToMicroseconds(const int64_t ticks);
-
   // Returns a TickTime that is ticks later than the passed TickTime.
   friend TickTime operator+(const TickTime lhs, const int64_t ticks);
   TickTime& operator+=(const int64_t& ticks);
 
   // Returns a TickInterval that is the difference in ticks beween rhs and lhs.
   friend TickInterval operator-(const TickTime& lhs, const TickTime& rhs);
 
   // Call to engage the fake clock. This is useful for tests since relying on
   // a real clock often makes the test flaky.
   static void UseFakeClock(int64_t start_millisecond);
@@ skipping 36 matching lines @@
  private:
   explicit TickInterval(int64_t interval);
 
   friend class TickTime;
   friend TickInterval operator-(const TickTime& lhs, const TickTime& rhs);
 
  private:
   int64_t interval_;
 };
 
-inline int64_t TickInterval::Milliseconds() const {
-  return TickTime::TicksToMilliseconds(interval_);
-}
-
-inline int64_t TickInterval::Microseconds() const {
-  return TickTime::TicksToMicroseconds(interval_);
-}
-
 inline TickInterval operator+(const TickInterval& lhs,
                               const TickInterval& rhs) {
   return TickInterval(lhs.interval_ + rhs.interval_);
 }
 
 inline TickInterval operator-(const TickInterval& lhs,
                               const TickInterval& rhs) {
   return TickInterval(lhs.interval_ - rhs.interval_);
 }
 
@@ skipping 31 matching lines @@
     : ticks_(ticks) {
 }
 
 inline TickTime TickTime::Now() {
   if (use_fake_clock_)
     return TickTime(fake_ticks_);
   else
     return TickTime(QueryOsForTicks());
 }
 
+inline int64_t TickTime::MillisecondTimestamp() {
+  int64_t ticks = TickTime::Now().Ticks();
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (ticks * 1000) / qpfreq.QuadPart;
+#else
+  return ticks;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  return ticks / 1000000LL;
+#else
+  return ticks / 1000LL;
+#endif
+}
+
+inline int64_t TickTime::MicrosecondTimestamp() {
+  int64_t ticks = TickTime::Now().Ticks();
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (ticks * 1000) / (qpfreq.QuadPart / 1000);
+#else
+  return ticks * 1000LL;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  return ticks / 1000LL;
+#else
+  return ticks;
+#endif
+}
+
 inline int64_t TickTime::Ticks() const {
   return ticks_;
 }
 
+inline int64_t TickTime::MillisecondsToTicks(const int64_t ms) {
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (qpfreq.QuadPart * ms) / 1000;
+#else
+  return ms;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  return ms * 1000000LL;
+#else
+  return ms * 1000LL;
+#endif
+}
+
+inline int64_t TickTime::TicksToMilliseconds(const int64_t ticks) {
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (ticks * 1000) / qpfreq.QuadPart;
+#else
+  return ticks;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  return ticks / 1000000LL;
+#else
+  return ticks / 1000LL;
+#endif
+}
+
 inline TickTime& TickTime::operator+=(const int64_t& ticks) {
   ticks_ += ticks;
   return *this;
 }
 
 inline TickInterval::TickInterval() : interval_(0) {
 }
 
 inline TickInterval::TickInterval(const int64_t interval)
   : interval_(interval) {
 }
 
+inline int64_t TickInterval::Milliseconds() const {
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (interval_ * 1000) / qpfreq.QuadPart;
+#else
+  // interval_ is in ms
+  return interval_;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  // interval_ is in ns
+  return interval_ / 1000000;
+#else
+  // interval_ is usecs
+  return interval_ / 1000;
+#endif
+}
+
+inline int64_t TickInterval::Microseconds() const {
+#if _WIN32
+#ifdef USE_QUERY_PERFORMANCE_COUNTER
+  LARGE_INTEGER qpfreq;
+  QueryPerformanceFrequency(&qpfreq);
+  return (interval_ * 1000000) / qpfreq.QuadPart;
+#else
+  // interval_ is in ms
+  return interval_ * 1000LL;
+#endif
+#elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
+  // interval_ is in ns
+  return interval_ / 1000;
+#else
+  // interval_ is usecs
+  return interval_;
+#endif
+}
+
 inline TickInterval& TickInterval::operator+=(const TickInterval& rhs) {
   interval_ += rhs.interval_;
   return *this;
 }
 
 inline TickInterval& TickInterval::operator-=(const TickInterval& rhs) {
   interval_ -= rhs.interval_;
   return *this;
 }
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_SYSTEM_WRAPPERS_INCLUDE_TICK_UTIL_H_