Use wpi mutex and condition_variable. (#52)

src/main/native/include/support/ConcurrentQueue.h

@@ -9,8 +9,9 @@
 
 #include <queue>
 #include <thread>
-#include <mutex>
-#include <condition_variable>
+
+#include "support/mutex.h"
+#include "support/condition_variable.h"
 
 namespace wpi {
 
@@ -18,17 +19,17 @@ template <typename T>
 class ConcurrentQueue {
  public:
   bool empty() const {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     return queue_.empty();
   }
 
   typename std::queue<T>::size_type size() const {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     return queue_.size();
   }
 
   T pop() {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     while (queue_.empty()) {
       cond_.wait(mlock);
     }
@@ -38,7 +39,7 @@ class ConcurrentQueue {
   }
 
   void pop(T& item) {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     while (queue_.empty()) {
       cond_.wait(mlock);
     }
@@ -47,14 +48,14 @@ class ConcurrentQueue {
   }
 
   void push(const T& item) {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     queue_.push(item);
     mlock.unlock();
     cond_.notify_one();
   }
 
   void push(T&& item) {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     queue_.push(std::forward<T>(item));
     mlock.unlock();
     cond_.notify_one();
@@ -62,7 +63,7 @@ class ConcurrentQueue {
 
   template <typename... Args>
   void emplace(Args&&... args) {
-    std::unique_lock<std::mutex> mlock(mutex_);
+    std::unique_lock<wpi::mutex> mlock(mutex_);
     queue_.emplace(std::forward<Args>(args)...);
     mlock.unlock();
     cond_.notify_one();
@@ -74,8 +75,8 @@ class ConcurrentQueue {
 
  private:
   std::queue<T> queue_;
-  mutable std::mutex mutex_;
-  std::condition_variable cond_;
+  mutable wpi::mutex mutex_;
+  wpi::condition_variable cond_;
 };
 
 }  // namespace wpi

src/main/native/include/support/SafeThread.h

@@ -9,10 +9,11 @@
 #define WPIUTIL_SUPPORT_SAFETHREAD_H_
 
 #include <atomic>
-#include <condition_variable>
-#include <mutex>
 #include <thread>
 
+#include "support/condition_variable.h"
+#include "support/mutex.h"
+
 namespace wpi {
 
 // Base class for SafeThreadOwner threads.
@@ -22,9 +23,9 @@ class SafeThread {
   virtual ~SafeThread() = default;
   virtual void Main() = 0;
 
-  std::mutex m_mutex;
+  wpi::mutex m_mutex;
   std::atomic_bool m_active;
-  std::condition_variable m_cond;
+  wpi::condition_variable m_cond;
 };
 
 namespace detail {
@@ -42,11 +43,11 @@ class SafeThreadProxyBase {
     }
   }
   explicit operator bool() const { return m_thread != nullptr; }
-  std::unique_lock<std::mutex>& GetLock() { return m_lock; }
+  std::unique_lock<wpi::mutex>& GetLock() { return m_lock; }
 
  protected:
   SafeThread* m_thread;
-  std::unique_lock<std::mutex> m_lock;
+  std::unique_lock<wpi::mutex> m_lock;
 };
 
 // A proxy for SafeThread.

src/main/native/include/support/jni_util.h

@@ -8,7 +8,6 @@
 #ifndef WPIUTIL_SUPPORT_JNI_UTIL_H_
 #define WPIUTIL_SUPPORT_JNI_UTIL_H_
 
-#include <mutex>
 #include <string>
 #include <type_traits>
 #include <queue>
@@ -24,6 +23,7 @@
 #include "llvm/StringRef.h"
 #include "support/atomic_static.h"
 #include "support/deprecated.h"
+#include "support/mutex.h"
 #include "support/SafeThread.h"
 
 namespace wpi {
@@ -473,7 +473,7 @@ void JCallbackThread<T>::Main() {
   jint rs = T::GetJVM()->AttachCurrentThreadAsDaemon((void**)&env, &args);
   if (rs != JNI_OK) return;
 
-  std::unique_lock<std::mutex> lock(m_mutex);
+  std::unique_lock<wpi::mutex> lock(m_mutex);
   while (m_active) {
     m_cond.wait(lock, [&] { return !(m_active && m_queue.empty()); });
     if (!m_active) break;