Inline internal usages of Mutex::Lock, etc. in favor of lock.

PiperOrigin-RevId: 789459507
Change-Id: I573dec1c33b047388509cfea129342ea7bdfe494

Author: ckennelly

absl/flags/internal/flag.cc

@@ -73,8 +73,8 @@ bool ShouldValidateFlagValue(FlagFastTypeId flag_type_id) {
 // need to acquire these locks themselves.
 class MutexRelock {
  public:
-  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); }
-  ~MutexRelock() { mu_.Lock(); }
+  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.unlock(); }
+  ~MutexRelock() { mu_.lock(); }
 
   MutexRelock(const MutexRelock&) = delete;
   MutexRelock& operator=(const MutexRelock&) = delete;

absl/flags/reflection.cc

@@ -53,8 +53,11 @@ class FlagRegistry {
   // Store a flag in this registry. Takes ownership of *flag.
   void RegisterFlag(CommandLineFlag& flag, const char* filename);
 
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
-  void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
+  void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.lock(); }
+  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock(); }
+
+  void unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.unlock(); }
+  inline void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { unlock(); }
 
   // Returns the flag object for the specified name, or nullptr if not found.
   // Will emit a warning if a 'retired' flag is specified.
@@ -87,8 +90,8 @@ namespace {
 
 class FlagRegistryLock {
  public:
-  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); }
-  ~FlagRegistryLock() { fr_.Unlock(); }
+  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.lock(); }
+  ~FlagRegistryLock() { fr_.unlock(); }
 
  private:
   FlagRegistry& fr_;

absl/strings/internal/cordz_info.cc

@@ -378,14 +378,14 @@ void CordzInfo::Untrack() {
 
 void CordzInfo::Lock(MethodIdentifier method)
     ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_) {
-  mutex_.Lock();
+  mutex_.lock();
   update_tracker_.LossyAdd(method);
   assert(rep_);
 }
 
 void CordzInfo::Unlock() ABSL_UNLOCK_FUNCTION(mutex_) {
   bool tracked = rep_ != nullptr;
-  mutex_.Unlock();
+  mutex_.unlock();
   if (!tracked) {
     Untrack();
   }

absl/synchronization/lifetime_test.cc

@@ -148,12 +148,12 @@ ABSL_CONST_INIT absl::Mutex early_const_init_mutex(absl::kConstInit);
 // before the constructors of either grab_lock or check_still_locked are run.)
 extern absl::Mutex const_init_sanity_mutex;
 OnConstruction grab_lock([]() ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  const_init_sanity_mutex.Lock();
+  const_init_sanity_mutex.lock();
 });
 ABSL_CONST_INIT absl::Mutex const_init_sanity_mutex(absl::kConstInit);
 OnConstruction check_still_locked([]() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   const_init_sanity_mutex.AssertHeld();
-  const_init_sanity_mutex.Unlock();
+  const_init_sanity_mutex.unlock();
 });
 #endif  // defined(__clang__) || !(defined(_MSC_VER) && _MSC_VER > 1900)
 

absl/synchronization/mutex.cc

@@ -2760,7 +2760,7 @@ void CondVar::SignalAll() {
 void ReleasableMutexLock::Release() {
   ABSL_RAW_CHECK(this->mu_ != nullptr,
                  "ReleasableMutexLock::Release may only be called once");
-  this->mu_->Unlock();
+  this->mu_->unlock();
   this->mu_ = nullptr;
 }
 

absl/synchronization/mutex.h

@@ -599,11 +599,11 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
   // Constructors
 
-  // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
+  // Calls `mu->lock()` and returns when that call returns. That is, `*mu` is
   // guaranteed to be locked when this object is constructed. Requires that
   // `mu` be dereferenceable.
   explicit MutexLock(Mutex& mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
-    this->mu_.Lock();
+    this->mu_.lock();
   }
 
   explicit MutexLock(Mutex* absl_nonnull mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
@@ -623,7 +623,7 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
   MutexLock& operator=(const MutexLock&) = delete;
   MutexLock& operator=(MutexLock&&) = delete;
 
-  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.Unlock(); }
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }
 
  private:
   Mutex& mu_;
@@ -657,7 +657,7 @@ class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
   ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
   ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
 
-  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.ReaderUnlock(); }
+  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock_shared(); }
 
  private:
   Mutex& mu_;
@@ -1049,7 +1049,7 @@ class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
       ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     if (this->mu_ != nullptr) {
-      this->mu_->Lock();
+      this->mu_->lock();
     }
   }
 
@@ -1063,7 +1063,7 @@ class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
 
   ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) {
-      this->mu_->Unlock();
+      this->mu_->unlock();
     }
   }
 
@@ -1084,7 +1084,7 @@ class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
   explicit ReleasableMutexLock(Mutex* absl_nonnull mu)
       ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
-    this->mu_->Lock();
+    this->mu_->lock();
   }
 
   explicit ReleasableMutexLock(Mutex* absl_nonnull mu, const Condition& cond)
@@ -1095,7 +1095,7 @@ class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
 
   ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) {
-      this->mu_->Unlock();
+      this->mu_->unlock();
     }
   }
 

absl/synchronization/mutex_benchmark.cc

@@ -46,8 +46,8 @@ BENCHMARK(BM_ReaderLock)->UseRealTime()->Threads(1)->ThreadPerCpu();
 void BM_TryLock(benchmark::State& state) {
   absl::Mutex mu;
   for (auto _ : state) {
-    if (mu.TryLock()) {
-      mu.Unlock();
+    if (mu.try_lock()) {
+      mu.unlock();
     }
   }
 }
@@ -56,8 +56,8 @@ BENCHMARK(BM_TryLock);
 void BM_ReaderTryLock(benchmark::State& state) {
   static absl::NoDestructor<absl::Mutex> mu;
   for (auto _ : state) {
-    if (mu->ReaderTryLock()) {
-      mu->ReaderUnlock();
+    if (mu->try_lock_shared()) {
+      mu->unlock_shared();
     }
   }
 }
@@ -273,7 +273,7 @@ void BM_ConditionWaiters(benchmark::State& state) {
       init->DecrementCount();
       m->LockWhen(absl::Condition(
           static_cast<bool (*)(int*)>([](int* v) { return *v == 0; }), p));
-      m->Unlock();
+      m->unlock();
     }
   };
 
@@ -299,15 +299,15 @@ void BM_ConditionWaiters(benchmark::State& state) {
   init.Wait();
 
   for (auto _ : state) {
-    mu.Lock();
-    mu.Unlock();  // Each unlock requires Condition evaluation for our waiters.
+    mu.lock();
+    mu.unlock();  // Each unlock requires Condition evaluation for our waiters.
   }
 
-  mu.Lock();
+  mu.lock();
   for (int i = 0; i < num_classes; i++) {
     equivalence_classes[i] = 0;
   }
-  mu.Unlock();
+  mu.unlock();
 }
 
 // Some configurations have higher thread limits than others.