WTF: Simplify ThreadCondition interface and make it more similar to base::ConditionVariable.

There are no uses of TimedWait in Blink, so it is removed altogether.

Bug: 856641
Change-Id: I3fa1dad9374a2600decddad18f80bf47f00b7b78
Reviewed-on: https://chromium-review.googlesource.com/1199933Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Jeremy Roman <jbroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588425}

third_party/blink/renderer/bindings/core/v8/script_streamer.cc

@@ -35,8 +35,7 @@ class SourceStreamDataQueue {
   WTF_MAKE_NONCOPYABLE(SourceStreamDataQueue);
 
  public:
-  SourceStreamDataQueue() : finished_(false) {}
-
+  SourceStreamDataQueue() : finished_(false), have_data_(mutex_) {}
   ~SourceStreamDataQueue() { DiscardQueuedData(); }
 
   void Clear() {
@@ -61,7 +60,7 @@ class SourceStreamDataQueue {
   void Consume(const uint8_t** data, size_t* length) {
     MutexLocker locker(mutex_);
     while (!TryGetData(data, length))
-      have_data_.Wait(mutex_);
+      have_data_.Wait();
   }
 
  private:

third_party/blink/renderer/core/inspector/inspector_task_runner.cc

@@ -25,7 +25,7 @@ InspectorTaskRunner::IgnoreInterruptsScope::~IgnoreInterruptsScope() {
 
 InspectorTaskRunner::InspectorTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> isolate_task_runner)
-    : isolate_task_runner_(isolate_task_runner) {}
+    : isolate_task_runner_(isolate_task_runner), condition_(mutex_) {}
 
 InspectorTaskRunner::~InspectorTaskRunner() = default;
 
@@ -88,7 +88,7 @@ InspectorTaskRunner::Task InspectorTaskRunner::TakeNextTask(
 
   if (wait_mode == kWaitForTask) {
     while (!disposed_ && queue_.IsEmpty())
-      condition_.Wait(mutex_);
+      condition_.Wait();
   }
 
   if (disposed_ || queue_.IsEmpty())

third_party/blink/renderer/platform/heap/heap_test.cc

@@ -5484,12 +5484,13 @@ static Mutex& MainThreadMutex() {
 }
 
 static ThreadCondition& MainThreadCondition() {
-  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadCondition, main_condition, ());
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadCondition, main_condition,
+                                  (MainThreadMutex()));
   return main_condition;
 }
 
 static void ParkMainThread() {
-  MainThreadCondition().Wait(MainThreadMutex());
+  MainThreadCondition().Wait();
 }
 
 static void WakeMainThread() {
@@ -5503,12 +5504,13 @@ static Mutex& WorkerThreadMutex() {
 }
 
 static ThreadCondition& WorkerThreadCondition() {
-  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadCondition, worker_condition, ());
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadCondition, worker_condition,
+                                  (WorkerThreadMutex()));
   return worker_condition;
 }
 
 static void ParkWorkerThread() {
-  WorkerThreadCondition().Wait(WorkerThreadMutex());
+  WorkerThreadCondition().Wait();
 }
 
 static void WakeWorkerThread() {

third_party/blink/renderer/platform/wtf/threading_primitives.h

@@ -150,20 +150,16 @@ class WTF_EXPORT ThreadCondition final {
   USING_FAST_MALLOC(ThreadCondition);  // Only HeapTest.cpp requires.
 
  public:
-  ThreadCondition();
+  explicit ThreadCondition(Mutex&);
   ~ThreadCondition();
 
-  void Wait(Mutex&);
-  // Returns true if the condition was signaled before absoluteTime, false if
-  // the absoluteTime was reached or is in the past.
-  // The absoluteTime is in seconds, starting on January 1, 1970. The time is
-  // assumed to use the same time zone as WTF::currentTime().
-  bool TimedWait(Mutex&, double absolute_time);
+  void Wait();
   void Signal();
   void Broadcast();
 
  private:
   PlatformCondition condition_;
+  PlatformMutex& mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadCondition);
 };

third_party/blink/renderer/platform/wtf/threading_primitives_test.cc

@@ -25,18 +25,13 @@ class MockBlockingObserver : public base::internal::BlockingObserver {
 
 class ThreadConditionTest : public testing::Test {
  public:
-  void RunOtherThreadInfiniteWait() {
-    base::internal::SetBlockingObserverForCurrentThread(&observer_);
-    MutexLocker lock(mutex_);
-    ready_.Signal();
-    condition_.Wait(mutex_);
-  }
+  ThreadConditionTest() : condition_(mutex_) {}
 
-  void RunOtherThreadTimedWait() {
+  void RunOtherThreadInfiniteWait() {
     base::internal::SetBlockingObserverForCurrentThread(&observer_);
     MutexLocker lock(mutex_);
     ready_.Signal();
-    condition_.TimedWait(mutex_, CurrentTime() + 10.0);
+    condition_.Wait();
   }
 
  protected:
@@ -62,20 +57,5 @@ TEST_F(ThreadConditionTest, WaitReportsBlockingCall) {
   condition_.Signal();
 }
 
-TEST_F(ThreadConditionTest, TimedWaitReportsBlockingCall) {
-  EXPECT_CALL(observer_, BlockingStarted(base::BlockingType::MAY_BLOCK));
-  EXPECT_CALL(observer_, BlockingEnded());
-
-  base::Thread other_thread("other thread");
-  other_thread.StartAndWaitForTesting();
-  other_thread.task_runner()->PostTask(
-      FROM_HERE, base::BindOnce(&ThreadConditionTest::RunOtherThreadTimedWait,
-                                base::Unretained(this)));
-
-  ready_.Wait();
-  MutexLocker lock(mutex_);
-  condition_.Signal();
-}
-
 }  // namespace
 }  // namespace WTF

third_party/blink/renderer/platform/wtf/threading_pthreads.cc

@@ -142,7 +142,7 @@ bool RecursiveMutex::TryLock() {
   return false;
 }
 
-ThreadCondition::ThreadCondition() {
+ThreadCondition::ThreadCondition(Mutex& mutex) : mutex_(mutex.Impl()) {
   pthread_cond_init(&condition_, nullptr);
 }
 
@@ -150,46 +150,16 @@ ThreadCondition::~ThreadCondition() {
   pthread_cond_destroy(&condition_);
 }
 
-void ThreadCondition::Wait(Mutex& mutex) {
+void ThreadCondition::Wait() {
   base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::MAY_BLOCK);
-  PlatformMutex& platform_mutex = mutex.Impl();
 #if DCHECK_IS_ON()
-  --platform_mutex.recursion_count_;
+  --mutex_.recursion_count_;
 #endif
-  int result = pthread_cond_wait(&condition_, &platform_mutex.internal_mutex_);
+  int result = pthread_cond_wait(&condition_, &mutex_.internal_mutex_);
   DCHECK_EQ(result, 0);
 #if DCHECK_IS_ON()
-  ++platform_mutex.recursion_count_;
-#endif
-}
-
-bool ThreadCondition::TimedWait(Mutex& mutex, double absolute_time) {
-  if (absolute_time < CurrentTime())
-    return false;
-
-  if (absolute_time > INT_MAX) {
-    Wait(mutex);
-    return true;
-  }
-
-  int time_seconds = static_cast<int>(absolute_time);
-  int time_nanoseconds = static_cast<int>((absolute_time - time_seconds) * 1E9);
-
-  timespec target_time;
-  target_time.tv_sec = time_seconds;
-  target_time.tv_nsec = time_nanoseconds;
-
-  base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::MAY_BLOCK);
-  PlatformMutex& platform_mutex = mutex.Impl();
-#if DCHECK_IS_ON()
-  --platform_mutex.recursion_count_;
-#endif
-  int result = pthread_cond_timedwait(
-      &condition_, &platform_mutex.internal_mutex_, &target_time);
-#if DCHECK_IS_ON()
-  ++platform_mutex.recursion_count_;
+  ++mutex_.recursion_count_;
 #endif
-  return result == 0;
 }
 
 void ThreadCondition::Signal() {

third_party/blink/renderer/platform/wtf/threading_win.cc

@@ -175,47 +175,19 @@ bool RecursiveMutex::TryLock() {
   return true;
 }
 
-ThreadCondition::ThreadCondition() {
+ThreadCondition::ThreadCondition(Mutex& mutex) : mutex_(mutex.Impl()) {
   InitializeConditionVariable(&condition_);
 }
 
 ThreadCondition::~ThreadCondition() {}
 
-void ThreadCondition::Wait(Mutex& mutex) {
-  PlatformMutex& platform_mutex = mutex.Impl();
+void ThreadCondition::Wait() {
   base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::MAY_BLOCK);
-  --platform_mutex.recursion_count_;
-  BOOL result = SleepConditionVariableCS(
-      &condition_, &platform_mutex.internal_mutex_, INFINITE);
+  --mutex_.recursion_count_;
+  BOOL result =
+      SleepConditionVariableCS(&condition_, &mutex_.internal_mutex_, INFINITE);
   DCHECK_NE(result, 0);
-  ++platform_mutex.recursion_count_;
-}
-
-bool ThreadCondition::TimedWait(Mutex& mutex, double absolute_time) {
-  double current_time = WTF::CurrentTime();
-
-  // Time is in the past - return immediately.
-  if (absolute_time <= current_time) {
-    // Consider the wait to have timed out, even if our condition has already
-    // been signaled, to match the pthreads implementation.
-    return false;
-  }
-
-  // If time is too far in the future (and would overflow unsigned long), wait
-  // forever.
-  DWORD interval =
-      (absolute_time - current_time > static_cast<double>(INT_MAX) / 1000.0)
-          ? INFINITE
-          : ((absolute_time - current_time) * 1000.0);
-
-  base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::MAY_BLOCK);
-  PlatformMutex& platform_mutex = mutex.Impl();
-  --platform_mutex.recursion_count_;
-  BOOL result = SleepConditionVariableCS(
-      &condition_, &platform_mutex.internal_mutex_, interval);
-  ++platform_mutex.recursion_count_;
-
-  return result != 0;
+  ++mutex_.recursion_count_;
 }
 
 void ThreadCondition::Signal() {