Use wpi::mutex instead of std::mutex. (#105)

This uses a priority-aware mutex on Linux platforms.

src/main/native/cpp/HttpCameraImpl.cpp

@@ -27,7 +27,7 @@ HttpCameraImpl::~HttpCameraImpl() {
 
   // Close file if it's open
   {
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     if (m_streamConn) m_streamConn->stream->close();
     if (m_settingsConn) m_settingsConn->stream->close();
   }
@@ -69,7 +69,7 @@ void HttpCameraImpl::StreamThreadMain() {
 
     // disconnect if no one is listening
     if (m_numSinksEnabled == 0) {
-      std::unique_lock<std::mutex> lock(m_mutex);
+      std::unique_lock<wpi::mutex> lock(m_mutex);
       if (m_streamConn) m_streamConn->stream->close();
       // Wait for a sink to enable
       m_sinkEnabledCond.wait(
@@ -102,7 +102,7 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
   // Build the request
   wpi::HttpRequest req;
   {
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     if (m_locations.empty()) {
       SERROR("locations array is empty!?");
       std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -124,14 +124,14 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
 
   // update m_streamConn
   {
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     m_streamConn = std::move(connPtr);
   }
 
   std::string warn;
   if (!conn->Handshake(req, &warn)) {
     SWARNING(GetName() << ": " << warn);
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     m_streamConn = nullptr;
     return nullptr;
   }
@@ -143,7 +143,7 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
   if (mediaType != "multipart/x-mixed-replace") {
     SWARNING("\"" << req.host << "\": unrecognized Content-Type \"" << mediaType
                   << "\"");
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     m_streamConn = nullptr;
     return nullptr;
   }
@@ -165,7 +165,7 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
   if (boundary.empty()) {
     SWARNING("\"" << req.host
                   << "\": empty multi-part boundary or no Content-Type");
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     m_streamConn = nullptr;
     return nullptr;
   }
@@ -258,7 +258,7 @@ void HttpCameraImpl::SettingsThreadMain() {
   for (;;) {
     wpi::HttpRequest req;
     {
-      std::unique_lock<std::mutex> lock(m_mutex);
+      std::unique_lock<wpi::mutex> lock(m_mutex);
       m_settingsCond.wait(lock, [=] {
         return !m_active || (m_prefLocation != -1 && !m_settings.empty());
       });
@@ -286,7 +286,7 @@ void HttpCameraImpl::DeviceSendSettings(wpi::HttpRequest& req) {
 
   // update m_settingsConn
   {
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<wpi::mutex> lock(m_mutex);
     m_settingsConn = std::move(connPtr);
   }
 
@@ -298,7 +298,7 @@ void HttpCameraImpl::DeviceSendSettings(wpi::HttpRequest& req) {
 }
 
 CS_HttpCameraKind HttpCameraImpl::GetKind() const {
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   return m_kind;
 }
 
@@ -316,14 +316,14 @@ bool HttpCameraImpl::SetUrls(llvm::ArrayRef<std::string> urls,
     }
   }
 
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   m_locations.swap(locations);
   m_nextLocation = 0;
   return true;
 }
 
 std::vector<std::string> HttpCameraImpl::GetUrls() const {
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   std::vector<std::string> urls;
   for (const auto& loc : m_locations) urls.push_back(loc.url);
   return urls;
@@ -334,7 +334,7 @@ void HttpCameraImpl::CreateProperty(llvm::StringRef name,
                                     CS_PropertyKind kind, int minimum,
                                     int maximum, int step, int defaultValue,
                                     int value) const {
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   m_propertyData.emplace_back(llvm::make_unique<PropertyData>(
       name, httpParam, viaSettings, kind, minimum, maximum, step, defaultValue,
       value));
@@ -348,7 +348,7 @@ template <typename T>
 void HttpCameraImpl::CreateEnumProperty(
     llvm::StringRef name, llvm::StringRef httpParam, bool viaSettings,
     int defaultValue, int value, std::initializer_list<T> choices) const {
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   m_propertyData.emplace_back(llvm::make_unique<PropertyData>(
       name, httpParam, viaSettings, CS_PROP_ENUM, 0, choices.size() - 1, 1,
       defaultValue, value));
@@ -371,7 +371,7 @@ std::unique_ptr<PropertyImpl> HttpCameraImpl::CreateEmptyProperty(
 }
 
 bool HttpCameraImpl::CacheProperties(CS_Status* status) const {
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
 
   // Pretty typical set of video modes
   m_videoModes.clear();
@@ -427,7 +427,7 @@ void HttpCameraImpl::SetExposureManual(int value, CS_Status* status) {
 
 bool HttpCameraImpl::SetVideoMode(const VideoMode& mode, CS_Status* status) {
   if (mode.pixelFormat != VideoMode::kMJPEG) return false;
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   m_mode = mode;
   m_streamSettingsUpdated = true;
   return true;
@@ -456,7 +456,7 @@ bool AxisCameraImpl::CacheProperties(CS_Status* status) const {
                  true, CS_PROP_INTEGER, 0, 100, 1, 50, 50);
 
   // TODO: get video modes from device
-  std::lock_guard<std::mutex> lock(m_mutex);
+  std::lock_guard<wpi::mutex> lock(m_mutex);
   m_videoModes.clear();
   m_videoModes.emplace_back(VideoMode::kMJPEG, 640, 480, 30);
   m_videoModes.emplace_back(VideoMode::kMJPEG, 480, 360, 30);