diff --git a/sharing/nearby_connection_impl.cc b/sharing/nearby_connection_impl.cc
index d918c5a0..42ab97eb 100644
--- a/sharing/nearby_connection_impl.cc
+++ b/sharing/nearby_connection_impl.cc
@@ -38,7 +38,7 @@ NearbyConnectionImpl::~NearbyConnectionImpl() {
   std::function<void()> disconnect_listener;
   std::function<void(std::optional<std::vector<uint8_t>> bytes)> read_callback;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!device_info_.AllowSleep()) {
       LOG(ERROR) << __func__ << ":Failed to allow device sleep.";
     }
@@ -58,7 +58,7 @@ void NearbyConnectionImpl::Read(
     std::function<void(std::optional<std::vector<uint8_t>> bytes)> callback) {
   std::vector<uint8_t> bytes;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (reads_.empty()) {
       read_callback_ = std::move(callback);
       return;
@@ -72,14 +72,14 @@ void NearbyConnectionImpl::Read(
 
 void NearbyConnectionImpl::SetDisconnectionListener(
     std::function<void()> listener) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   disconnect_listener_ = std::move(listener);
 }
 
 void NearbyConnectionImpl::WriteMessage(std::vector<uint8_t> bytes) {
   std::function<void(std::optional<std::vector<uint8_t>> bytes)> read_callback;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!read_callback_) {
       reads_.push(std::move(bytes));
       return;
diff --git a/sharing/nearby_sharing_service_impl_test.cc b/sharing/nearby_sharing_service_impl_test.cc
index cf95612f..2b62f694 100644
--- a/sharing/nearby_sharing_service_impl_test.cc
+++ b/sharing/nearby_sharing_service_impl_test.cc
@@ -438,10 +438,10 @@ class NearbySharingServiceImplTest : public testing::Test {
             std::vector<uint8_t> data =
                 std::move(payload->content.bytes_payload.bytes);
             frame->ParseFromArray(data.data(), data.size());
-            absl::MutexLock lock(&connection_output_mutex_);
+            absl::MutexLock lock(connection_output_mutex_);
             frames_data_.push(std::move(frame));
           } else {
-            absl::MutexLock lock(&connection_output_mutex_);
+            absl::MutexLock lock(connection_output_mutex_);
             written_payloads_.push(PayloadInfo(std::move(payload), listener));
           }
         });
@@ -880,7 +880,7 @@ class NearbySharingServiceImplTest : public testing::Test {
   std::unique_ptr<Frame> GetWrittenFrame() {
     EXPECT_TRUE(
         sharing_service_task_runner_->SyncWithTimeout(kTaskWaitTimeout));
-    absl::MutexLock lock(&connection_output_mutex_);
+    absl::MutexLock lock(connection_output_mutex_);
     std::unique_ptr<Frame> frame = std::move(frames_data_.front());
     frames_data_.pop();
     return frame;
@@ -889,7 +889,7 @@ class NearbySharingServiceImplTest : public testing::Test {
   PayloadInfo GetWrittenPayload() {
     EXPECT_TRUE(
         sharing_service_task_runner_->SyncWithTimeout(kTaskWaitTimeout));
-    absl::MutexLock lock(&connection_output_mutex_);
+    absl::MutexLock lock(connection_output_mutex_);
     PayloadInfo info = std::move(written_payloads_.front());
     written_payloads_.pop();
     return info;
diff --git a/sharing/nearby_sharing_settings.cc b/sharing/nearby_sharing_settings.cc
index 38897605..78d983dc 100644
--- a/sharing/nearby_sharing_settings.cc
+++ b/sharing/nearby_sharing_settings.cc
@@ -97,7 +97,7 @@ NearbyShareSettings::NearbyShareSettings(
 }
 
 NearbyShareSettings::~NearbyShareSettings() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   is_desctructing_ = nullptr;
   preference_manager_.RemoveObserver(kPreferencesObserverName);
   local_device_data_manager_->RemoveObserver(this);
@@ -115,7 +115,7 @@ NearbyShareSettings::GetFastInitiationNotificationState() const {
 void NearbyShareSettings::SetIsFastInitiationHardwareSupported(
     bool is_supported) {
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     // If the new value is the same as the old value, don't notify observers.
     if (is_fast_initiation_hardware_supported_ == is_supported) {
       return;
@@ -146,7 +146,7 @@ void NearbyShareSettings::StartVisibilityTimer(
         LOG(INFO) << __func__ << ": visibility timer expired.";
         proto::DeviceVisibility visibility;
         {
-          absl::MutexLock lock(&mutex_);
+          absl::MutexLock lock(mutex_);
           visibility = fallback_visibility_;
           visibility_expiration_timer_.reset();
         }
@@ -241,7 +241,7 @@ DeviceVisibility NearbyShareSettings::GetVisibility() const {
 
 void NearbyShareSettings::SetVisibility(DeviceVisibility visibility,
                                         absl::Duration expiration) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (visibility == DeviceVisibility::DEVICE_VISIBILITY_SELECTED_CONTACTS) {
     // This should really be an error, but this function does not return errors,
     // so change it to self share as in GetVisibility().
@@ -287,12 +287,12 @@ void NearbyShareSettings::SetVisibility(DeviceVisibility visibility,
 }
 
 absl::Time NearbyShareSettings::GetLastVisibilityTimestamp() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return last_visibility_timestamp_;
 }
 
 proto::DeviceVisibility NearbyShareSettings::GetLastVisibility() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return static_cast<proto::DeviceVisibility>(last_visibility_);
 }
 
@@ -307,7 +307,7 @@ NearbyShareSettings::GetRawFallbackVisibility() const {
 
 NearbyShareSettings::FallbackVisibilityInfo
 NearbyShareSettings::GetFallbackVisibility() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   FallbackVisibilityInfo result{
       .visibility = DeviceVisibility::DEVICE_VISIBILITY_UNSPECIFIED,
       .fallback_time = absl::UnixEpoch(),
@@ -339,7 +339,7 @@ void NearbyShareSettings::SetFallbackVisibility(DeviceVisibility visibility) {
 
 void NearbyShareSettings::SetCustomSavePathAsync(
     absl::string_view save_path, const std::function<void()>& callback) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   preference_manager_.SetString(prefs::kNearbySharingCustomSavePath, save_path);
   callback();
 }
@@ -406,7 +406,7 @@ std::string NearbyShareSettings::Dump() const {
 }
 
 bool NearbyShareSettings::is_fast_initiation_hardware_supported() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return is_fast_initiation_hardware_supported_;
 }
 
diff --git a/sharing/nearby_sharing_settings_test.cc b/sharing/nearby_sharing_settings_test.cc
index 7dd3e1f0..ddd8eef2 100644
--- a/sharing/nearby_sharing_settings_test.cc
+++ b/sharing/nearby_sharing_settings_test.cc
@@ -48,7 +48,7 @@ constexpr char kDefaultDeviceName[] = "Josh's Chromebook";
 class FakeNearbyShareSettingsObserver : public NearbyShareSettings::Observer {
  public:
   void OnSettingChanged(absl::string_view key, const Data& data) override {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (key == prefs::kNearbySharingFastInitiationNotificationStateName) {
       fast_initiation_notification_state_ =
           static_cast<FastInitiationNotificationState>(data.value.as_int64);
@@ -64,37 +64,37 @@ class FakeNearbyShareSettingsObserver : public NearbyShareSettings::Observer {
   }
 
   void OnIsFastInitiationHardwareSupportedChanged(bool is_supported) override {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     is_fast_initiation_notification_hardware_supported_ = is_supported;
   }
 
   FastInitiationNotificationState fast_initiation_notification_state() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return fast_initiation_notification_state_;
   }
 
   bool is_fast_initiation_notification_hardware_supported() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return is_fast_initiation_notification_hardware_supported_;
   }
 
   std::string device_name() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return device_name_;
   }
 
   std::string custom_save_path() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return custom_save_path_;
   }
 
   DataUsage data_usage() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return data_usage_;
   }
 
   DeviceVisibility visibility() const {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     return visibility_;
   }
 
diff --git a/sharing/transfer_manager.cc b/sharing/transfer_manager.cc
index 5dee51a1..dede2870 100644
--- a/sharing/transfer_manager.cc
+++ b/sharing/transfer_manager.cc
@@ -48,13 +48,13 @@ TransferManager::TransferManager(Context* context,
     : context_(context), endpoint_id_(endpoint_id) {}
 
 TransferManager::~TransferManager() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   timeout_timer_.reset();
   pending_tasks_.clear();
 }
 
 void TransferManager::Send(std::function<void()> task) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   if (is_waiting_for_high_quality_medium_) {
     LOG(INFO)
@@ -68,7 +68,7 @@ void TransferManager::Send(std::function<void()> task) {
 }
 
 void TransferManager::OnMediumQualityChanged(Medium current_medium) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   if (!is_waiting_for_high_quality_medium_) {
     LOG(WARNING) << "It is not waiting for high quality medium.";
@@ -88,7 +88,7 @@ void TransferManager::OnMediumQualityChanged(Medium current_medium) {
 }
 
 bool TransferManager::StartTransfer() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   if (!is_waiting_for_high_quality_medium_) {
     VLOG(1) << "No need to wait for high quality medium.";
@@ -103,7 +103,7 @@ bool TransferManager::StartTransfer() {
   timeout_timer_ = std::make_unique<ThreadTimer>(
       *context_->GetTaskRunner(), "transfer_manager_timeout_timer",
       kMediumUpgradeTimeout, [this]() {
-        absl::MutexLock lock(&mutex_);
+        absl::MutexLock lock(mutex_);
 
         LOG(INFO) << "Timed out for endpoint " << endpoint_id_ << " after "
                   << kMediumUpgradeTimeout;
@@ -119,7 +119,7 @@ bool TransferManager::StartTransfer() {
 }
 
 bool TransferManager::CancelTransfer() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   if (timeout_timer_ == nullptr) {
     LOG(WARNING) << "No running transfer.";