clean-up: use Mutex reference and change lock interface p2 (#42673)

Replace absl::MutexLock::MutexLock(Mutex*) constructor with
absl::MutexLock::MutexLock(Mutex&)
Similar to #41948

Commit Message:
Additional Description:
Risk Level:
Testing:
Docs Changes:
Release Notes:
Platform Specific Features:

---------

Signed-off-by: Boteng Yao <boteng@google.com>

Author: botengyao

source/common/common/thread.h

@@ -129,7 +129,7 @@ class AtomicPtrArray : NonCopyable {
 
     // First, use an atomic load to see if the object has already been allocated.
     if (atomic_ref.load() == nullptr) {
-      absl::MutexLock lock(&mutex_);
+      absl::MutexLock lock(mutex_);
 
       // If that fails, check again under lock as two threads might have raced
       // to create the object.

source/common/stats/symbol_table.h

@@ -1045,7 +1045,7 @@ class StatNameSet {
    * @return The StatName for str.
    */
   StatName add(absl::string_view str) {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return pool_.add(str);
   }
 

source/extensions/clusters/redis/redis_cluster_lb.cc

@@ -79,7 +79,7 @@ bool RedisClusterLoadBalancerFactory::onClusterSlotUpdate(ClusterSlotsSharedPtr&
 void RedisClusterLoadBalancerFactory::onHostHealthUpdate() {
   ShardVectorSharedPtr current_shard_vector;
   {
-    absl::ReaderMutexLock lock(&mutex_);
+    absl::ReaderMutexLock lock(mutex_);
     current_shard_vector = shard_vector_;
   }
 
@@ -102,7 +102,7 @@ void RedisClusterLoadBalancerFactory::onHostHealthUpdate() {
 }
 
 Upstream::LoadBalancerPtr RedisClusterLoadBalancerFactory::create(Upstream::LoadBalancerParams) {
-  absl::ReaderMutexLock lock(&mutex_);
+  absl::ReaderMutexLock lock(mutex_);
   return std::make_unique<RedisClusterLoadBalancer>(slot_array_, shard_vector_, random_);
 }
 

source/extensions/http/cache/simple_http_cache/simple_http_cache.cc

@@ -211,7 +211,7 @@ void SimpleHttpCache::updateHeaders(const LookupContext& lookup_context,
 }
 
 SimpleHttpCache::Entry SimpleHttpCache::lookup(const LookupRequest& request) {
-  absl::ReaderMutexLock lock(&mutex_);
+  absl::ReaderMutexLock lock(mutex_);
   auto iter = map_.find(request.key());
   if (iter == map_.end()) {
     return Entry{};

source/extensions/load_balancing_policies/common/thread_aware_lb_impl.cc

@@ -224,7 +224,7 @@ LoadBalancerPtr ThreadAwareLoadBalancerBase::LoadBalancerFactoryImpl::create(Loa
 
   // We must protect current_lb_ via a RW lock since it is accessed and written to by multiple
   // threads. All complex processing has already been precalculated however.
-  absl::ReaderMutexLock lock(&mutex_);
+  absl::ReaderMutexLock lock(mutex_);
   lb->healthy_per_priority_load_ = healthy_per_priority_load_;
   lb->degraded_per_priority_load_ = degraded_per_priority_load_;
   lb->per_priority_state_ = per_priority_state_;

source/extensions/network/dns_resolver/getaddrinfo/getaddrinfo.h

@@ -51,18 +51,18 @@ class GetAddrInfoDnsResolver : public DnsResolver, public Logger::Loggable<Logge
 
     void cancel(CancelReason) override {
       ENVOY_LOG(trace, "cancelling query [{}]", dns_name_);
-      absl::MutexLock lock(&mutex_);
+      absl::MutexLock lock(mutex_);
       cancelled_ = true;
     }
 
     void addTrace(uint8_t trace) override {
-      absl::MutexLock lock(&mutex_);
+      absl::MutexLock lock(mutex_);
       traces_.push_back(
           Trace{trace, std::chrono::steady_clock::now()}); // NO_CHECK_FORMAT(real_time)
     }
 
     std::string getTraces() override {
-      absl::MutexLock lock(&mutex_);
+      absl::MutexLock lock(mutex_);
       std::vector<std::string> string_traces;
       string_traces.reserve(traces_.size());
       std::transform(traces_.begin(), traces_.end(), std::back_inserter(string_traces),
@@ -74,7 +74,7 @@ class GetAddrInfoDnsResolver : public DnsResolver, public Logger::Loggable<Logge
     }
 
     bool isCancelled() {
-      absl::MutexLock lock(&mutex_);
+      absl::MutexLock lock(mutex_);
       return cancelled_;
     }
 

test/extensions/watchdog/profile_action/profile_action_test.cc

@@ -112,11 +112,11 @@ TEST_F(ProfileActionTest, CanDoSingleProfile) {
   // Check that we can do at least a single profile
   dispatcher_->post([&tid_ltt_pairs, &now, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(2));
 
@@ -151,11 +151,11 @@ TEST_F(ProfileActionTest, CanDoMultipleProfiles) {
   // Check that we can do at least a single profile
   dispatcher_->post([&tid_ltt_pairs, &now, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(2));
 
@@ -169,7 +169,7 @@ TEST_F(ProfileActionTest, CanDoMultipleProfiles) {
   // Check we can do multiple profiles
   dispatcher_->post([&tid_ltt_pairs, &now, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
@@ -210,11 +210,11 @@ TEST_F(ProfileActionTest, CannotTriggerConcurrentProfiles) {
     // This subsequent call should fail since the one prior starts a profile.
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
 
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(6));
 
@@ -248,11 +248,11 @@ TEST_F(ProfileActionTest, ShouldNotProfileIfDirectoryDoesNotExist) {
 
   dispatcher_->post([&, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(6));
 
@@ -280,11 +280,11 @@ TEST_F(ProfileActionTest, ShouldNotProfileIfNoTids) {
     std::vector<std::pair<Thread::ThreadId, MonotonicTime>> tid_ltt_pairs;
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs,
                  api_->timeSource().monotonicTime());
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(2));
 
@@ -316,11 +316,11 @@ TEST_F(ProfileActionTest, ShouldSaturatedMaxProfiles) {
 
   dispatcher_->post([&, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   waitForOutstandingNotify();
   time_system_->advanceTimeWait(std::chrono::seconds(2));
 
@@ -335,7 +335,7 @@ TEST_F(ProfileActionTest, ShouldSaturatedMaxProfiles) {
   // Do another run of the watchdog action. It shouldn't have run again.
   dispatcher_->post([&, this]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
@@ -375,12 +375,12 @@ TEST_F(ProfileActionTest, ShouldUpdateCountersCorrectly) {
   dispatcher_->post([this, &tid_ltt_pairs]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs,
                  api_->timeSource().monotonicTime());
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     waitForOutstandingNotify();
     time_system_->advanceTimeWait(std::chrono::seconds(2));
   }
@@ -396,12 +396,12 @@ TEST_F(ProfileActionTest, ShouldUpdateCountersCorrectly) {
 
   dispatcher_->post([this, &tid_ltt_pairs, &now]() -> void {
     action_->run(envoy::config::bootstrap::v3::Watchdog::WatchdogAction::MISS, tid_ltt_pairs, now);
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     outstanding_notifies_ += 1;
   });
 
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     waitForOutstandingNotify();
     time_system_->advanceTimeWait(std::chrono::seconds(2));
   }

test/test_common/file_system_for_test.cc

@@ -17,7 +17,7 @@ struct MemFileInfo {
   SystemTime access_time_;
   SystemTime modify_time_;
   FileInfo toFileInfo(absl::string_view path) {
-    absl::MutexLock lock(&lock_);
+    absl::MutexLock lock(lock_);
     return {
         std::string{fileSystemForTest().splitPathFromFilename(path).value().file_},
         data_.length(),
@@ -43,14 +43,14 @@ class MemfileImpl : public FileSharedImpl {
     open_ = true;
     if (flags_.test(File::Operation::Write) && !flags_.test(File::Operation::Append) &&
         !flags_.test(File::Operation::KeepExistingData)) {
-      absl::MutexLock l(&info_->lock_);
+      absl::MutexLock l(info_->lock_);
       info_->data_.clear();
     }
     return resultSuccess(true);
   }
 
   Api::IoCallSizeResult write(absl::string_view buffer) override {
-    absl::MutexLock l(&info_->lock_);
+    absl::MutexLock l(info_->lock_);
     info_->data_.append(std::string(buffer));
     const ssize_t size = info_->data_.size();
     return resultSuccess(size);
@@ -73,7 +73,7 @@ class MemfileImpl : public FileSharedImpl {
 };
 
 Api::IoCallSizeResult MemfileImpl::pread(void* buf, uint64_t count, uint64_t offset) {
-  absl::MutexLock l(&info_->lock_);
+  absl::MutexLock l(info_->lock_);
   if (!flags_.test(File::Operation::Read)) {
     return resultFailure<ssize_t>(-1, EBADF);
   }
@@ -88,7 +88,7 @@ Api::IoCallSizeResult MemfileImpl::pread(void* buf, uint64_t count, uint64_t off
 }
 
 Api::IoCallSizeResult MemfileImpl::pwrite(const void* buf, uint64_t count, uint64_t offset) {
-  absl::MutexLock l(&info_->lock_);
+  absl::MutexLock l(info_->lock_);
   if (!flags_.test(File::Operation::Write)) {
     return resultFailure<ssize_t>(-1, EBADF);
   }
@@ -111,7 +111,7 @@ Api::IoCallResult<FileInfo> MemfileImpl::info() { return resultSuccess(info_->to
 
 Api::IoCallResult<FileInfo> MemfileInstanceImpl::stat(absl::string_view path) {
   {
-    absl::MutexLock m(&lock_);
+    absl::MutexLock m(lock_);
     auto it = files_.find(path);
     if (it != files_.end()) {
       ASSERT(use_memfiles_);
@@ -135,7 +135,7 @@ MemfileInstanceImpl& fileSystemForTest() {
 
 FilePtr MemfileInstanceImpl::createFile(const FilePathAndType& file_info) {
   const std::string& path = file_info.path_;
-  absl::MutexLock m(&lock_);
+  absl::MutexLock m(lock_);
   if (!use_memfiles_) {
     return file_system_->createFile(file_info);
   }
@@ -158,11 +158,11 @@ FilePtr MemfileInstanceImpl::createFile(const FilePathAndType& file_info) {
 
 ssize_t MemfileInstanceImpl::fileSize(const std::string& path) {
   {
-    absl::MutexLock m(&lock_);
+    absl::MutexLock m(lock_);
     auto it = files_.find(path);
     if (it != files_.end()) {
       ASSERT(use_memfiles_);
-      absl::MutexLock n(&it->second->lock_);
+      absl::MutexLock n(it->second->lock_);
       return it->second->data_.size();
     }
   }
@@ -171,10 +171,10 @@ ssize_t MemfileInstanceImpl::fileSize(const std::string& path) {
 
 absl::StatusOr<std::string> MemfileInstanceImpl::fileReadToEnd(const std::string& path) {
   {
-    absl::MutexLock m(&lock_);
+    absl::MutexLock m(lock_);
     auto it = files_.find(path);
     if (it != files_.end()) {
-      absl::MutexLock n(&it->second->lock_);
+      absl::MutexLock n(it->second->lock_);
       ASSERT(use_memfiles_);
       return it->second->data_;
     }
@@ -184,7 +184,7 @@ absl::StatusOr<std::string> MemfileInstanceImpl::fileReadToEnd(const std::string
 
 void MemfileInstanceImpl::renameFile(const std::string& old_name, const std::string& new_name) {
   {
-    absl::MutexLock m(&lock_);
+    absl::MutexLock m(lock_);
     // It's easy enough to change the key to the hash set, but most instances of
     // renameFile are to trigger file watches in core code, and those are not
     // mem-file-aware.

test/test_common/logging.cc

@@ -53,18 +53,18 @@ void LogRecordingSink::log(absl::string_view msg, const spdlog::details::log_msg
   previousDelegate()->log(msg, log_msg);
 
   if (enabled_) {
-    absl::MutexLock ml(&mtx_);
+    absl::MutexLock ml(mtx_);
     messages_.push_back(std::string(msg));
   }
 
-  absl::MutexLock ml(&exp_mtx_);
+  absl::MutexLock ml(exp_mtx_);
   for (auto* expect : expectations_) {
     expect->on_log_(static_cast<Logger::Logger::Levels>(log_msg.level), std::string(msg));
   }
 }
 
 const std::vector<std::string> LogRecordingSink::messages() const {
-  absl::MutexLock ml(&mtx_);
+  absl::MutexLock ml(mtx_);
   std::vector<std::string> copy(messages_);
   return copy;
 }
@@ -77,17 +77,17 @@ void LogRecordingSink::start() {
 void LogRecordingSink::stop() {
   ASSERT(enabled_);
   enabled_ = false;
-  absl::MutexLock ml(&mtx_);
+  absl::MutexLock ml(mtx_);
   messages_.clear();
 }
 
 void LogRecordingSink::addExpectation(LogExpectation* exp) {
-  absl::MutexLock ml(&exp_mtx_);
+  absl::MutexLock ml(exp_mtx_);
   expectations_.insert(exp);
 }
 
 void LogRecordingSink::removeExpectation(LogExpectation* exp) {
-  absl::MutexLock ml(&exp_mtx_);
+  absl::MutexLock ml(exp_mtx_);
   expectations_.erase(exp);
 }