Introduce non-locking variant of client_state::cleanup()

The method takes already locked lock object as an argument.
The caller must ensure that the lock object owns the underlying mutex.

Replaced homegrown wsrep::unique_lock with type alias from
std::unique_lock.

include/wsrep/lock.hpp

@@ -20,57 +20,12 @@
 #ifndef WSREP_LOCK_HPP
 #define WSREP_LOCK_HPP
 
-#include "mutex.hpp"
-
-#include <cassert>
+#include <mutex>
 
 namespace wsrep
 {
-    template <class M>
-    class unique_lock
-    {
-    public:
-        unique_lock(M& mutex)
-            : mutex_(mutex)
-            , locked_(false)
-        {
-            mutex_.lock();
-            locked_ = true;
-        }
-        ~unique_lock()
-        {
-            if (locked_)
-            {
-                unlock();
-            }
-        }
-
-        void lock()
-        {
-            mutex_.lock();
-            assert(locked_ == false);
-            locked_ = true;
-        }
-
-        void unlock()
-        {
-            assert(locked_);
-            locked_ = false;
-            mutex_.unlock();
-        }
-
-        bool owns_lock() const
-        {
-            return locked_;
-        }
-
-        M& mutex() { return mutex_; }
-    private:
-        unique_lock(const unique_lock&);
-        unique_lock& operator=(const unique_lock&);
-        M& mutex_;
-        bool locked_;
-    };
+    template <class C>
+    using unique_lock = std::unique_lock<C>;
 }
 
 #endif // WSREP_LOCK_HPP