scripted-diff: rename m_cs_callbacks_pending -> m_callbacks_mutex

-BEGIN VERIFY SCRIPT-
sed -i 's/m_cs_callbacks_pending/m_callbacks_mutex/g' ./src/scheduler.h ./src/scheduler.cpp
-END VERIFY SCRIPT

Author: theStack

src/scheduler.cpp

@@ -136,7 +136,7 @@ bool CScheduler::AreThreadsServicingQueue() const
 void SingleThreadedSchedulerClient::MaybeScheduleProcessQueue()
 {
     {
-        LOCK(m_cs_callbacks_pending);
+        LOCK(m_callbacks_mutex);
         // Try to avoid scheduling too many copies here, but if we
         // accidentally have two ProcessQueue's scheduled at once its
         // not a big deal.
@@ -150,7 +150,7 @@ void SingleThreadedSchedulerClient::ProcessQueue()
 {
     std::function<void()> callback;
     {
-        LOCK(m_cs_callbacks_pending);
+        LOCK(m_callbacks_mutex);
         if (m_are_callbacks_running) return;
         if (m_callbacks_pending.empty()) return;
         m_are_callbacks_running = true;
@@ -167,7 +167,7 @@ void SingleThreadedSchedulerClient::ProcessQueue()
         ~RAIICallbacksRunning()
         {
             {
-                LOCK(instance->m_cs_callbacks_pending);
+                LOCK(instance->m_callbacks_mutex);
                 instance->m_are_callbacks_running = false;
             }
             instance->MaybeScheduleProcessQueue();
@@ -182,7 +182,7 @@ void SingleThreadedSchedulerClient::AddToProcessQueue(std::function<void()> func
     assert(m_pscheduler);
 
     {
-        LOCK(m_cs_callbacks_pending);
+        LOCK(m_callbacks_mutex);
         m_callbacks_pending.emplace_back(std::move(func));
     }
     MaybeScheduleProcessQueue();
@@ -194,13 +194,13 @@ void SingleThreadedSchedulerClient::EmptyQueue()
     bool should_continue = true;
     while (should_continue) {
         ProcessQueue();
-        LOCK(m_cs_callbacks_pending);
+        LOCK(m_callbacks_mutex);
         should_continue = !m_callbacks_pending.empty();
     }
 }
 
 size_t SingleThreadedSchedulerClient::CallbacksPending()
 {
-    LOCK(m_cs_callbacks_pending);
+    LOCK(m_callbacks_mutex);
     return m_callbacks_pending.size();
 }

src/scheduler.h

@@ -119,9 +119,9 @@ class SingleThreadedSchedulerClient
 private:
     CScheduler* m_pscheduler;
 
-    RecursiveMutex m_cs_callbacks_pending;
-    std::list<std::function<void()>> m_callbacks_pending GUARDED_BY(m_cs_callbacks_pending);
-    bool m_are_callbacks_running GUARDED_BY(m_cs_callbacks_pending) = false;
+    RecursiveMutex m_callbacks_mutex;
+    std::list<std::function<void()>> m_callbacks_pending GUARDED_BY(m_callbacks_mutex);
+    bool m_are_callbacks_running GUARDED_BY(m_callbacks_mutex) = false;
 
     void MaybeScheduleProcessQueue();
     void ProcessQueue();