Fix race condition in EventTimerPosix

webrtc/system_wrappers/source/event_timer_posix_unittest.cc

+/*
+ *  Copyright (c) 2016 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 "webrtc/system_wrappers/source/event_timer_posix.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/event.h"
+#include "webrtc/base/criticalsection.h"
+
+namespace webrtc {
+
+enum class ThreadState {
+  kNotStarted,
+  kWaiting,
+  kRequestProcessCall,
+  kCallingProcess,
+  kProcessDone,
+  kContinue,
+  kExiting,
+  kDead
+};
+
+class EventTimerPosixTest : public testing::Test, public EventTimerPosix {
+ public:
+  EventTimerPosixTest()
+      : thread_state_(ThreadState::kNotStarted),
+        process_event_(false, true),
+        main_event_(false, true),
+        process_thread_id_(0),
+        process_thread_(nullptr) {}
+  virtual ~EventTimerPosixTest() {}
+
+  rtc::PlatformThread* CreateThread() override {
+    EXPECT_TRUE(process_thread_ == nullptr);
+    process_thread_ =
+        new rtc::PlatformThread(Run, this, "EventTimerPosixTestThread");
+    return process_thread_;
+  }
+
+  static bool Run(void* obj) {
+    return static_cast<EventTimerPosixTest*>(obj)->Process();
+  }
+
+  bool Process() {
+    bool res = ProcessInternal();
+    if (!res) {
+      rtc::CritScope cs(&lock_);
+      thread_state_ = ThreadState::kDead;
+      main_event_.Set();
+    }
+    return res;
+  }
+
+  bool ProcessInternal() {
+    {
+      rtc::CritScope cs(&lock_);
+      if (thread_state_ == ThreadState::kNotStarted) {
+        if (!ChangeThreadState(ThreadState::kNotStarted,
+                               ThreadState::kContinue)) {
+          ADD_FAILURE() << "Unable to start process thread";
+          return false;
+        }
+        process_thread_id_ = rtc::CurrentThreadId();
+      }
+    }
+
+    if (!ChangeThreadState(ThreadState::kContinue, ThreadState::kWaiting))
+      return false;
+
+    if (!AwaitThreadState(ThreadState::kRequestProcessCall,
+                          rtc::Event::kForever))
+      return false;
+
+    if (!ChangeThreadState(ThreadState::kRequestProcessCall,
+                           ThreadState::kCallingProcess))
+      return false;
+
+    EventTimerPosix::Process();
+
+    if (!ChangeThreadState(ThreadState::kCallingProcess,
+                           ThreadState::kProcessDone))
+      return false;
+
+    if (!AwaitThreadState(ThreadState::kContinue, rtc::Event::kForever))
+      return false;
+
+    return true;
+  }
+
+  bool IsProcessThread() {
+    rtc::CritScope cs(&lock_);
+    return process_thread_id_ == rtc::CurrentThreadId();
+  }
+
+  bool ChangeThreadState(ThreadState prev_state, ThreadState new_state) {
+    rtc::CritScope cs(&lock_);
+    if (thread_state_ != prev_state)
+      return false;
+    thread_state_ = new_state;
+    if (IsProcessThread()) {
+      main_event_.Set();
+    } else {
+      process_event_.Set();
+    }
+    return true;
+  }
+
+  bool AwaitThreadState(ThreadState state, int timeout) {
+    rtc::Event* event = IsProcessThread() ? &process_event_ : &main_event_;
+    do {
+      rtc::CritScope cs(&lock_);
+      if (state != ThreadState::kDead && thread_state_ == ThreadState::kExiting)
+        return false;
+      if (thread_state_ == state)
+        return true;
+    } while (event->Wait(timeout));
+    return false;
+  }
+
+  bool CallProcess(int timeout_ms) {
+    return AwaitThreadState(ThreadState::kWaiting, timeout_ms) &&
+           ChangeThreadState(ThreadState::kWaiting,
+                             ThreadState::kRequestProcessCall);
+  }
+
+  bool AwaitProcessDone(int timeout_ms) {
+    return AwaitThreadState(ThreadState::kProcessDone, timeout_ms) &&
+           ChangeThreadState(ThreadState::kProcessDone, ThreadState::kContinue);
+  }
+
+  void TearDown() override {
+    if (process_thread_) {
+      {
+        rtc::CritScope cs(&lock_);
+        if (thread_state_ != ThreadState::kDead) {
+          thread_state_ = ThreadState::kExiting;
+          process_event_.Set();
+        }
+      }
+      ASSERT_TRUE(AwaitThreadState(ThreadState::kDead, 5000));
+    }
+  }
+
+  ThreadState thread_state_;
+  rtc::CriticalSection lock_;
+  rtc::Event process_event_;
+  rtc::Event main_event_;
+  rtc::PlatformThreadId process_thread_id_;
+  rtc::PlatformThread* process_thread_;
+};
+
+TEST_F(EventTimerPosixTest, WaiterBlocksUntilTimeout) {
+  const int kTimerIntervalMs = 100;
+  const int kTimeoutMs = 5000;
+  ASSERT_TRUE(StartTimer(false, kTimerIntervalMs));
+  ASSERT_TRUE(CallProcess(kTimeoutMs));
+  EventTypeWrapper res = Wait(kTimeoutMs);
+  EXPECT_EQ(kEventSignaled, res);
+  ASSERT_TRUE(AwaitProcessDone(kTimeoutMs));
+}
+
+TEST_F(EventTimerPosixTest, WaiterWakesImmediatelyAfterTimeout) {
+  const int kTimerIntervalMs = 100;
+  const int kTimeoutMs = 5000;
+  ASSERT_TRUE(StartTimer(false, kTimerIntervalMs));
+  ASSERT_TRUE(CallProcess(kTimeoutMs));
+  ASSERT_TRUE(AwaitProcessDone(kTimeoutMs));
+  EventTypeWrapper res = Wait(0);
+  EXPECT_EQ(kEventSignaled, res);
+}
+
+TEST_F(EventTimerPosixTest, WaiterBlocksUntilTimeoutProcessInactiveOnStart) {
+  const int kTimerIntervalMs = 100;
+  const int kTimeoutMs = 5000;
+  // First call to StartTimer initializes thread.
+  ASSERT_TRUE(StartTimer(false, kTimerIntervalMs));
+
+  // Process thread currently _not_ blocking on Process() call.
+  ASSERT_TRUE(AwaitThreadState(ThreadState::kWaiting, kTimeoutMs));
+
+  // Start new one-off timer, then call Process().
+  ASSERT_TRUE(StartTimer(false, kTimerIntervalMs));
+  ASSERT_TRUE(CallProcess(kTimeoutMs));
+
+  EventTypeWrapper res = Wait(kTimeoutMs);
+  EXPECT_EQ(kEventSignaled, res);
+
+  ASSERT_TRUE(AwaitProcessDone(kTimeoutMs));
+}
+
+}  // namespace webrtc