[idd] common: use CSRWLock throughout the drivers

Make CSRWLock own the native lock and provide scoped guards for shared,
exclusive, early-unlock, and non-blocking use.

Replace direct SRW lock management throughout the IDD, input driver,
and helper while preserving the existing lock scopes.

idd/LGCommon/CPipeEndpoint.cpp

@@ -224,13 +224,14 @@ bool CPipeEndpoint::Start(
     DEBUG_ERROR_HR(GetLastError(), "Failed to create named pipe thread");
     m_running.store(false);
 
-    AcquireSRWLockExclusive(&m_pipeLock);
-    if (m_pipe != INVALID_HANDLE_VALUE)
     {
-      CloseHandle(m_pipe);
-      m_pipe = INVALID_HANDLE_VALUE;
+      CSRWExclusiveLock lock(m_pipeLock);
+      if (m_pipe != INVALID_HANDLE_VALUE)
+      {
+        CloseHandle(m_pipe);
+        m_pipe = INVALID_HANDLE_VALUE;
+      }
     }
-    ReleaseSRWLockExclusive(&m_pipeLock);
 
     CloseHandle(m_stopEvent);
     m_stopEvent = nullptr;
@@ -249,10 +250,11 @@ void CPipeEndpoint::Stop()
   if (m_stopEvent)
     SetEvent(m_stopEvent);
 
-  AcquireSRWLockShared(&m_pipeLock);
-  if (m_pipe != INVALID_HANDLE_VALUE)
-    CancelIoEx(m_pipe, nullptr);
-  ReleaseSRWLockShared(&m_pipeLock);
+  {
+    CSRWSharedLock lock(m_pipeLock);
+    if (m_pipe != INVALID_HANDLE_VALUE)
+      CancelIoEx(m_pipe, nullptr);
+  }
 
   if (m_thread)
   {
@@ -261,13 +263,14 @@ void CPipeEndpoint::Stop()
     m_thread = nullptr;
   }
 
-  AcquireSRWLockExclusive(&m_pipeLock);
-  if (m_pipe != INVALID_HANDLE_VALUE)
   {
-    CloseHandle(m_pipe);
-    m_pipe = INVALID_HANDLE_VALUE;
+    CSRWExclusiveLock lock(m_pipeLock);
+    if (m_pipe != INVALID_HANDLE_VALUE)
+    {
+      CloseHandle(m_pipe);
+      m_pipe = INVALID_HANDLE_VALUE;
+    }
   }
-  ReleaseSRWLockExclusive(&m_pipeLock);
 
   if (m_stopEvent)
   {
@@ -290,7 +293,7 @@ bool CPipeEndpoint::Send(const void * message, size_t size)
     return false;
 
   bool success = false;
-  AcquireSRWLockExclusive(&m_pipeLock);
+  CSRWExclusiveLock lock(m_pipeLock);
   if (m_pipe != INVALID_HANDLE_VALUE && IsConnected())
   {
     const PipeIoResult result = WriteMessage(
@@ -304,7 +307,6 @@ bool CPipeEndpoint::Send(const void * message, size_t size)
       CancelIoEx(m_pipe, nullptr);
     }
   }
-  ReleaseSRWLockExclusive(&m_pipeLock);
   return success;
 }
 
@@ -350,18 +352,21 @@ void CPipeEndpoint::RunServer()
   if (!ioEvent)
   {
     DEBUG_ERROR_HR(GetLastError(), "Failed to create named pipe I/O event");
-    AcquireSRWLockShared(&m_pipeLock);
-    const HANDLE pipe = m_pipe;
-    ReleaseSRWLockShared(&m_pipeLock);
+    HANDLE pipe;
+    {
+      CSRWSharedLock lock(m_pipeLock);
+      pipe = m_pipe;
+    }
     if (pipe != INVALID_HANDLE_VALUE)
       ClosePipe(pipe);
     return;
   }
 
   HANDLE pipe = INVALID_HANDLE_VALUE;
-  AcquireSRWLockShared(&m_pipeLock);
-  pipe = m_pipe;
-  ReleaseSRWLockShared(&m_pipeLock);
+  {
+    CSRWSharedLock lock(m_pipeLock);
+    pipe = m_pipe;
+  }
 
   while (IsRunning())
   {
@@ -581,16 +586,14 @@ bool CPipeEndpoint::WaitForRetry(DWORD delayMs)
 
 void CPipeEndpoint::PublishPipe(HANDLE pipe)
 {
-  AcquireSRWLockExclusive(&m_pipeLock);
+  CSRWExclusiveLock lock(m_pipeLock);
   m_pipe = pipe;
-  ReleaseSRWLockExclusive(&m_pipeLock);
 }
 
 void CPipeEndpoint::ClosePipe(HANDLE pipe)
 {
-  AcquireSRWLockExclusive(&m_pipeLock);
+  CSRWExclusiveLock lock(m_pipeLock);
   if (m_pipe == pipe)
     m_pipe = INVALID_HANDLE_VALUE;
   CloseHandle(pipe);
-  ReleaseSRWLockExclusive(&m_pipeLock);
 }

idd/LGCommon/CPipeEndpoint.h

@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include "CSRWLock.h"
+
 #include <Windows.h>
 
 #include <atomic>
@@ -124,7 +126,7 @@ private:
   std::atomic<bool> m_running { false };
   std::atomic<bool> m_connected { false };
 
-  SRWLOCK m_pipeLock = SRWLOCK_INIT;
+  CSRWLock m_pipeLock;
   HANDLE m_pipe = INVALID_HANDLE_VALUE;
   HANDLE m_thread = nullptr;
   HANDLE m_stopEvent = nullptr;

idd/LGCommon/CSRWLock.h

@@ -22,42 +22,110 @@
 
 #include <Windows.h>
 
+class CSRWSharedLock;
+class CSRWExclusiveLock;
+
+class CSRWLock
+{
+private:
+  friend class CSRWSharedLock;
+  friend class CSRWExclusiveLock;
+
+  SRWLOCK m_lock = SRWLOCK_INIT;
+
+public:
+  CSRWLock() = default;
+
+  CSRWLock(const CSRWLock&) = delete;
+  CSRWLock& operator=(const CSRWLock&) = delete;
+};
+
 class CSRWSharedLock
 {
 private:
   SRWLOCK * m_lock;
 
 public:
-  explicit CSRWSharedLock(SRWLOCK * lock) : m_lock(lock)
+  explicit CSRWSharedLock(CSRWLock& lock) : m_lock(&lock.m_lock)
   {
     AcquireSRWLockShared(m_lock);
   }
 
   ~CSRWSharedLock()
   {
+    Unlock();
+  }
+
+  void Unlock()
+  {
+    if (!m_lock)
+      return;
+
     ReleaseSRWLockShared(m_lock);
+    m_lock = nullptr;
   }
 
   CSRWSharedLock(const CSRWSharedLock&) = delete;
   CSRWSharedLock& operator=(const CSRWSharedLock&) = delete;
+
+  CSRWSharedLock(CSRWSharedLock&& other) noexcept : m_lock(other.m_lock)
+  {
+    other.m_lock = nullptr;
+  }
+
+  CSRWSharedLock& operator=(CSRWSharedLock&&) = delete;
 };
 
 class CSRWExclusiveLock
 {
 private:
+  struct TryTag {};
+
   SRWLOCK * m_lock;
 
+  CSRWExclusiveLock(CSRWLock& lock, TryTag) :
+    m_lock(TryAcquireSRWLockExclusive(&lock.m_lock) ? &lock.m_lock : nullptr)
+  {
+  }
+
 public:
-  explicit CSRWExclusiveLock(SRWLOCK * lock) : m_lock(lock)
+  explicit CSRWExclusiveLock(CSRWLock& lock) : m_lock(&lock.m_lock)
   {
     AcquireSRWLockExclusive(m_lock);
   }
 
   ~CSRWExclusiveLock()
   {
+    Unlock();
+  }
+
+  static CSRWExclusiveLock Try(CSRWLock& lock)
+  {
+    return CSRWExclusiveLock(lock, TryTag {});
+  }
+
+  explicit operator bool() const
+  {
+    return m_lock != nullptr;
+  }
+
+  void Unlock()
+  {
+    if (!m_lock)
+      return;
+
     ReleaseSRWLockExclusive(m_lock);
+    m_lock = nullptr;
   }
 
   CSRWExclusiveLock(const CSRWExclusiveLock&) = delete;
   CSRWExclusiveLock& operator=(const CSRWExclusiveLock&) = delete;
+
+  CSRWExclusiveLock(CSRWExclusiveLock&& other) noexcept :
+    m_lock(other.m_lock)
+  {
+    other.m_lock = nullptr;
+  }
+
+  CSRWExclusiveLock& operator=(CSRWExclusiveLock&&) = delete;
 };