Remove non-monotonic clock support

webrtc/system_wrappers/source/event_timer_posix.cc

 /*
  *  Copyright (c) 2011 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 23 matching lines @@
     : event_set_(false),
       timer_thread_(nullptr),
       created_at_(),
       periodic_(false),
       time_(0),
       count_(0) {
   pthread_mutexattr_t attr;
   pthread_mutexattr_init(&attr);
   pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
   pthread_mutex_init(&mutex_, &attr);
-#ifdef WEBRTC_CLOCK_TYPE_REALTIME
-  pthread_cond_init(&cond_, 0);
-#else
   pthread_condattr_t cond_attr;
   pthread_condattr_init(&cond_attr);
+// TODO(sprang): Remove HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC special case once
+// all supported Android platforms support pthread_condattr_setclock.
+// TODO(sprang): Add support for monotonic clock on Apple platforms.
+#if !(defined(WEBRTC_MAC) || defined(WEBRTC_IOS)) && \
+    !(defined(WEBRTC_ANDROID) &&                     \
+      defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
   pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC);
+#endif
   pthread_cond_init(&cond_, &cond_attr);
   pthread_condattr_destroy(&cond_attr);
-#endif
 }
 
 EventTimerPosix::~EventTimerPosix() {
   StopTimer();
   pthread_cond_destroy(&cond_);
   pthread_mutex_destroy(&mutex_);
 }
 
 // TODO(pbos): Make this void.
 bool EventTimerPosix::Set() {
   RTC_CHECK_EQ(0, pthread_mutex_lock(&mutex_));
   event_set_ = true;
   pthread_cond_signal(&cond_);
   pthread_mutex_unlock(&mutex_);
   return true;
 }
 
 EventTypeWrapper EventTimerPosix::Wait(unsigned long timeout) {
   int ret_val = 0;
   RTC_CHECK_EQ(0, pthread_mutex_lock(&mutex_));
 
   if (!event_set_) {
     if (WEBRTC_EVENT_INFINITE != timeout) {
       timespec end_at;
 #ifndef WEBRTC_MAC
-#ifdef WEBRTC_CLOCK_TYPE_REALTIME
-      clock_gettime(CLOCK_REALTIME, &end_at);
-#else
       clock_gettime(CLOCK_MONOTONIC, &end_at);
-#endif
 #else
       timeval value;
       struct timezone time_zone;
       time_zone.tz_minuteswest = 0;
       time_zone.tz_dsttime = 0;
       gettimeofday(&value, &time_zone);
       TIMEVAL_TO_TIMESPEC(&value, &end_at);
 #endif
       end_at.tv_sec  += timeout / 1000;
       end_at.tv_nsec += (timeout - (timeout / 1000) * 1000) * E6;
 
       if (end_at.tv_nsec >= E9) {
         end_at.tv_sec++;
         end_at.tv_nsec -= E9;
       }
-      while (ret_val == 0 && !event_set_)
+      while (ret_val == 0 && !event_set_) {
+#if defined(WEBRTC_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC)
+        ret_val = pthread_cond_timedwait_monotonic_np(&cond_, &mutex_, &end_at);
+#else
         ret_val = pthread_cond_timedwait(&cond_, &mutex_, &end_at);
+#endif  // WEBRTC_ANDROID && HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC
+      }
     } else {
       while (ret_val == 0 && !event_set_)
         ret_val = pthread_cond_wait(&cond_, &mutex_);
     }
   }
 
   RTC_DCHECK(ret_val == 0 || ret_val == ETIMEDOUT);
 
   // Reset and signal if set, regardless of why the thread woke up.
   if (event_set_) {
     ret_val = 0;
     event_set_ = false;
   }
   pthread_mutex_unlock(&mutex_);
 
   return ret_val == 0 ? kEventSignaled : kEventTimeout;
 }
 
 EventTypeWrapper EventTimerPosix::Wait(timespec* end_at) {
   int ret_val = 0;
   RTC_CHECK_EQ(0, pthread_mutex_lock(&mutex_));
 
-  while (ret_val == 0 && !event_set_)
+  while (ret_val == 0 && !event_set_) {
+#if defined(WEBRTC_ANDROID) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC)
+    ret_val = pthread_cond_timedwait_monotonic_np(&cond_, &mutex_, end_at);
+#else
     ret_val = pthread_cond_timedwait(&cond_, &mutex_, end_at);
+#endif  // WEBRTC_ANDROID && HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC
+  }
 
   RTC_DCHECK(ret_val == 0 || ret_val == ETIMEDOUT);
 
   // Reset and signal if set, regardless of why the thread woke up.
   if (event_set_) {
     ret_val = 0;
     event_set_ = false;
   }
   pthread_mutex_unlock(&mutex_);
 
@@ skipping 31 matching lines @@
 }
 
 bool EventTimerPosix::Run(void* obj) {
   return static_cast<EventTimerPosix*>(obj)->Process();
 }
 
 bool EventTimerPosix::Process() {
   pthread_mutex_lock(&mutex_);
   if (created_at_.tv_sec == 0) {
 #ifndef WEBRTC_MAC
-#ifdef WEBRTC_CLOCK_TYPE_REALTIME
-    clock_gettime(CLOCK_REALTIME, &created_at_);
-#else
     clock_gettime(CLOCK_MONOTONIC, &created_at_);
-#endif
 #else
     timeval value;
     struct timezone time_zone;
     time_zone.tz_minuteswest = 0;
     time_zone.tz_dsttime = 0;
     gettimeofday(&value, &time_zone);
     TIMEVAL_TO_TIMESPEC(&value, &created_at_);
 #endif
     count_ = 0;
   }
@@ skipping 30 matching lines @@
   }
   timer_event_.reset();
 
   // Set time to zero to force new reference time for the timer.
   memset(&created_at_, 0, sizeof(created_at_));
   count_ = 0;
   return true;
 }
 
 }  // namespace webrtc