Move webrtc/{base => rtc_base}

webrtc/base/timeutils.cc

Index: webrtc/base/timeutils.cc
diff --git a/webrtc/base/timeutils.cc b/webrtc/base/timeutils.cc
deleted file mode 100644
index ee1415f4d22c82680117685c7d550e5221d2cd07..0000000000000000000000000000000000000000
--- a/webrtc/base/timeutils.cc
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- *  Copyright 2004 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.
- */
-
-#include <stdint.h>
-
-#if defined(WEBRTC_POSIX)
-#include <sys/time.h>
-#if defined(WEBRTC_MAC)
-#include <mach/mach_time.h>
-#endif
-#endif
-
-#if defined(WEBRTC_WIN)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#include <mmsystem.h>
-#include <sys/timeb.h>
-#endif
-
-#include "webrtc/base/checks.h"
-#include "webrtc/base/timeutils.h"
-
-namespace rtc {
-
-ClockInterface* g_clock = nullptr;
-
-ClockInterface* SetClockForTesting(ClockInterface* clock) {
-  ClockInterface* prev = g_clock;
-  g_clock = clock;
-  return prev;
-}
-
-ClockInterface* GetClockForTesting() {
-  return g_clock;
-}
-
-int64_t SystemTimeNanos() {
-  int64_t ticks;
-#if defined(WEBRTC_MAC)
-  static mach_timebase_info_data_t timebase;
-  if (timebase.denom == 0) {
-    // Get the timebase if this is the first time we run.
-    // Recommended by Apple's QA1398.
-    if (mach_timebase_info(&timebase) != KERN_SUCCESS) {
-      RTC_NOTREACHED();
-    }
-  }
-  // Use timebase to convert absolute time tick units into nanoseconds.
-  ticks = mach_absolute_time() * timebase.numer / timebase.denom;
-#elif defined(WEBRTC_POSIX)
-  struct timespec ts;
-  // TODO(deadbeef): Do we need to handle the case when CLOCK_MONOTONIC is not
-  // supported?
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  ticks = kNumNanosecsPerSec * static_cast<int64_t>(ts.tv_sec) +
-          static_cast<int64_t>(ts.tv_nsec);
-#elif defined(WEBRTC_WIN)
-  static volatile LONG last_timegettime = 0;
-  static volatile int64_t num_wrap_timegettime = 0;
-  volatile LONG* last_timegettime_ptr = &last_timegettime;
-  DWORD now = timeGetTime();
-  // Atomically update the last gotten time
-  DWORD old = InterlockedExchange(last_timegettime_ptr, now);
-  if (now < old) {
-    // If now is earlier than old, there may have been a race between threads.
-    // 0x0fffffff ~3.1 days, the code will not take that long to execute
-    // so it must have been a wrap around.
-    if (old > 0xf0000000 && now < 0x0fffffff) {
-      num_wrap_timegettime++;
-    }
-  }
-  ticks = now + (num_wrap_timegettime << 32);
-  // TODO(deadbeef): Calculate with nanosecond precision. Otherwise, we're
-  // just wasting a multiply and divide when doing Time() on Windows.
-  ticks = ticks * kNumNanosecsPerMillisec;
-#else
-#error Unsupported platform.
-#endif
-  return ticks;
-}
-
-int64_t SystemTimeMillis() {
-  return static_cast<int64_t>(SystemTimeNanos() / kNumNanosecsPerMillisec);
-}
-
-int64_t TimeNanos() {
-  if (g_clock) {
-    return g_clock->TimeNanos();
-  }
-  return SystemTimeNanos();
-}
-
-uint32_t Time32() {
-  return static_cast<uint32_t>(TimeNanos() / kNumNanosecsPerMillisec);
-}
-
-int64_t TimeMillis() {
-  return TimeNanos() / kNumNanosecsPerMillisec;
-}
-
-int64_t TimeMicros() {
-  return TimeNanos() / kNumNanosecsPerMicrosec;
-}
-
-int64_t TimeAfter(int64_t elapsed) {
-  RTC_DCHECK_GE(elapsed, 0);
-  return TimeMillis() + elapsed;
-}
-
-int32_t TimeDiff32(uint32_t later, uint32_t earlier) {
-  return later - earlier;
-}
-
-int64_t TimeDiff(int64_t later, int64_t earlier) {
-  return later - earlier;
-}
-
-TimestampWrapAroundHandler::TimestampWrapAroundHandler()
-    : last_ts_(0), num_wrap_(-1) {}
-
-int64_t TimestampWrapAroundHandler::Unwrap(uint32_t ts) {
-  if (num_wrap_ == -1) {
-    last_ts_ = ts;
-    num_wrap_ = 0;
-    return ts;
-  }
-
-  if (ts < last_ts_) {
-    if (last_ts_ >= 0xf0000000 && ts < 0x0fffffff)
-      ++num_wrap_;
-  } else if ((ts - last_ts_) > 0xf0000000) {
-    // Backwards wrap. Unwrap with last wrap count and don't update last_ts_.
-    return ts + ((num_wrap_ - 1) << 32);
-  }
-
-  last_ts_ = ts;
-  return ts + (num_wrap_ << 32);
-}
-
-int64_t TmToSeconds(const std::tm& tm) {
-  static short int mdays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-  static short int cumul_mdays[12] = {0,   31,  59,  90,  120, 151,
-                                      181, 212, 243, 273, 304, 334};
-  int year = tm.tm_year + 1900;
-  int month = tm.tm_mon;
-  int day = tm.tm_mday - 1;  // Make 0-based like the rest.
-  int hour = tm.tm_hour;
-  int min = tm.tm_min;
-  int sec = tm.tm_sec;
-
-  bool expiry_in_leap_year = (year % 4 == 0 &&
-                              (year % 100 != 0 || year % 400 == 0));
-
-  if (year < 1970)
-    return -1;
-  if (month < 0 || month > 11)
-    return -1;
-  if (day < 0 || day >= mdays[month] + (expiry_in_leap_year && month == 2 - 1))
-    return -1;
-  if (hour < 0 || hour > 23)
-    return -1;
-  if (min < 0 || min > 59)
-    return -1;
-  if (sec < 0 || sec > 59)
-    return -1;
-
-  day += cumul_mdays[month];
-
-  // Add number of leap days between 1970 and the expiration year, inclusive.
-  day += ((year / 4 - 1970 / 4) - (year / 100 - 1970 / 100) +
-          (year / 400 - 1970 / 400));
-
-  // We will have added one day too much above if expiration is during a leap
-  // year, and expiration is in January or February.
-  if (expiry_in_leap_year && month <= 2 - 1) // |month| is zero based.
-    day -= 1;
-
-  // Combine all variables into seconds from 1970-01-01 00:00 (except |month|
-  // which was accumulated into |day| above).
-  return (((static_cast<int64_t>
-            (year - 1970) * 365 + day) * 24 + hour) * 60 + min) * 60 + sec;
-}
-
-int64_t TimeUTCMicros() {
-#if defined(WEBRTC_POSIX)
-  struct timeval time;
-  gettimeofday(&time, nullptr);
-  // Convert from second (1.0) and microsecond (1e-6).
-  return (static_cast<int64_t>(time.tv_sec) * rtc::kNumMicrosecsPerSec +
-          time.tv_usec);
-
-#elif defined(WEBRTC_WIN)
-  struct _timeb time;
-  _ftime(&time);
-  // Convert from second (1.0) and milliseconds (1e-3).
-  return (static_cast<int64_t>(time.time) * rtc::kNumMicrosecsPerSec +
-          static_cast<int64_t>(time.millitm) * rtc::kNumMicrosecsPerMillisec);
-#endif
-}
-
-} // namespace rtc