Automated Code Change

PiperOrigin-RevId: 801577756

internal/platform/implementation/g3/awdl.cc

@@ -50,7 +50,7 @@ std::string AwdlServerSocket::GetName(const std::string& ip_address, int port) {
 }
 
 std::unique_ptr<api::AwdlSocket> AwdlServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -68,7 +68,7 @@ std::unique_ptr<api::AwdlSocket> AwdlServerSocket::Accept() {
 }
 
 bool AwdlServerSocket::Connect(AwdlSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR) << "Failed to connect to Awdl server socket: already connected";
@@ -85,17 +85,17 @@ bool AwdlServerSocket::Connect(AwdlSocket& socket) {
 }
 
 void AwdlServerSocket::SetCloseNotifier(absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 AwdlServerSocket::~AwdlServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception AwdlServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -106,11 +106,11 @@ Exception AwdlServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -133,7 +133,7 @@ bool AwdlMedium::StartAdvertising(const NsdServiceInfo& nsd_service_info) {
             << ", service_name=" << nsd_service_info.GetServiceName()
             << ", service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (advertising_info_.Existed(service_type)) {
       LOG(INFO) << "G3 AWDL StartAdvertising: Can't start advertising because "
                    "service_type="
@@ -145,7 +145,7 @@ bool AwdlMedium::StartAdvertising(const NsdServiceInfo& nsd_service_info) {
   env.UpdateAwdlMediumForAdvertising(*this, nsd_service_info,
                                      /*enabled=*/true);
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     advertising_info_.Add(service_type);
   }
   return true;
@@ -157,7 +157,7 @@ bool AwdlMedium::StopAdvertising(const NsdServiceInfo& nsd_service_info) {
             << ", service_name=" << nsd_service_info.GetServiceName()
             << ", service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!advertising_info_.Existed(service_type)) {
       LOG(INFO) << "G3 AWDL StopAdvertising: Can't stop advertising because "
                    "we never started advertising for service_type="
@@ -176,7 +176,7 @@ bool AwdlMedium::StartDiscovery(const std::string& service_type,
                                 DiscoveredServiceCallback callback) {
   LOG(INFO) << "G3 AWDL StartDiscovery: service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (discovering_info_.Existed(service_type)) {
       LOG(INFO) << "G3 AWDL StartDiscovery: Can't start discovery because "
                    "service_type="
@@ -188,7 +188,7 @@ bool AwdlMedium::StartDiscovery(const std::string& service_type,
   env.UpdateAwdlMediumForDiscovery(*this, std::move(callback), service_type,
                                    true);
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     discovering_info_.Add(service_type);
   }
   return true;
@@ -197,7 +197,7 @@ bool AwdlMedium::StartDiscovery(const std::string& service_type,
 bool AwdlMedium::StopDiscovery(const std::string& service_type) {
   LOG(INFO) << "G3 AWDL StopDiscovery: service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!discovering_info_.Existed(service_type)) {
       LOG(INFO) << "G3 AWDL StopDiscovery: Can't stop discovering because we "
                    "never started discovering.";
@@ -239,7 +239,7 @@ std::unique_ptr<api::AwdlSocket> AwdlMedium::ConnectToService(
             << ", remote ip address + port=" << socket_name;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&remote_medium->mutex_);
+    absl::MutexLock medium_lock(remote_medium->mutex_);
     auto item = remote_medium->server_sockets_.find(socket_name);
     server_socket =
         item != remote_medium->server_sockets_.end() ? item->second : nullptr;
@@ -293,12 +293,12 @@ std::unique_ptr<api::AwdlServerSocket> AwdlMedium::ListenForService(int port) {
   std::string socket_name = AwdlServerSocket::GetName(
       server_socket->GetIPAddress(), server_socket->GetPort());
   server_socket->SetCloseNotifier([this, socket_name]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     server_sockets_.erase(socket_name);
   });
   LOG(INFO) << "G3 AWDL Adding server socket: medium=" << this
             << ", socket_name=" << socket_name;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   server_sockets_.insert({socket_name, server_socket.get()});
   return server_socket;
 }

internal/platform/implementation/g3/ble.cc

@@ -38,13 +38,13 @@ namespace nearby {
 namespace g3 {
 
 BlePeripheral* BleSocket::GetRemotePeripheral() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return peripheral_;
 }
 
 std::unique_ptr<api::BleSocket> BleServerSocket::Accept(
     BlePeripheral* peripheral) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return {};
   while (pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
@@ -62,7 +62,7 @@ std::unique_ptr<api::BleSocket> BleServerSocket::Accept(
 }
 
 bool BleServerSocket::Connect(BleSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR) << "Failed to connect to Ble server socket: already connected";
@@ -79,17 +79,17 @@ bool BleServerSocket::Connect(BleSocket& socket) {
 }
 
 void BleServerSocket::SetCloseNotifier(absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 BleServerSocket::~BleServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception BleServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -100,11 +100,11 @@ Exception BleServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -154,7 +154,7 @@ bool BleMedium::StartAdvertising(
   env.UpdateBleMediumForAdvertising(*this, peripheral, service_id,
                                     fast_advertisement, true);
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (server_socket_ != nullptr) server_socket_.release();
   server_socket_ = std::make_unique<BleServerSocket>();
 
@@ -177,7 +177,7 @@ bool BleMedium::StartAdvertising(
 bool BleMedium::StopAdvertising(const std::string& service_id) {
   LOG(INFO) << "G3 Ble StopAdvertising: service_id=" << service_id;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (advertising_info_.Empty()) {
       LOG(INFO) << "G3 Ble StopAdvertising: Can't stop advertising "
                    "because we never started advertising.";
@@ -218,7 +218,7 @@ bool BleMedium::StartScanning(
                                  fast_advertisement_service_uuid,
                                  std::move(callback), true);
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     scanning_info_.service_id = service_id;
   }
   return true;
@@ -227,7 +227,7 @@ bool BleMedium::StartScanning(
 bool BleMedium::StopScanning(const std::string& service_id) {
   LOG(INFO) << "G3 Ble StopScanning: service_id=" << service_id;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (scanning_info_.Empty()) {
       LOG(INFO) << "G3 Ble StopDiscovery: Can't stop scanning because "
                    "we never started scanning.";
@@ -276,7 +276,7 @@ std::unique_ptr<api::BleSocket> BleMedium::Connect(
             << ", service_id=" << service_id;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&medium->mutex_);
+    absl::MutexLock medium_lock(medium->mutex_);
     remote_server_socket = medium->server_socket_.get();
     if (remote_server_socket == nullptr) {
       LOG(ERROR)

internal/platform/implementation/g3/ble_v2.cc

@@ -82,7 +82,7 @@ api::ble_v2::BlePeripheral::UniqueId BleV2Socket::GetRemotePeripheralId() {
 }
 
 std::unique_ptr<api::ble_v2::BleSocket> BleV2ServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -100,7 +100,7 @@ std::unique_ptr<api::ble_v2::BleSocket> BleV2ServerSocket::Accept() {
 }
 
 bool BleV2ServerSocket::Connect(BleV2Socket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(WARNING) << "Failed to connect to Ble server socket: already connected";
@@ -117,17 +117,17 @@ bool BleV2ServerSocket::Connect(BleV2Socket& socket) {
 }
 
 void BleV2ServerSocket::SetCloseNotifier(absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 BleV2ServerSocket::~BleV2ServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception BleV2ServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -138,11 +138,11 @@ Exception BleV2ServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -180,7 +180,7 @@ bool BleV2Medium::StartAdvertising(
     return false;
   }
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   MediumEnvironment::Instance().UpdateBleV2MediumForAdvertising(
       /*enabled=*/true, *this, adapter_.GetUniqueId(), advertising_data);
   return true;
@@ -188,7 +188,7 @@ bool BleV2Medium::StartAdvertising(
 
 bool BleV2Medium::StopAdvertising() {
   LOG(INFO) << "G3 Ble StopAdvertising";
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   BleAdvertisementData empty_advertisement_data = {};
   MediumEnvironment::Instance().UpdateBleV2MediumForAdvertising(
@@ -218,7 +218,7 @@ std::unique_ptr<BleV2Medium::AdvertisingSession> BleV2Medium::StartAdvertising(
   if (callback.start_advertising_result) {
     callback.start_advertising_result(absl::OkStatus());
   }
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   MediumEnvironment::Instance().UpdateBleV2MediumForAdvertising(
       /*enabled=*/true, *this, adapter_.GetUniqueId(), advertising_data);
   return std::make_unique<AdvertisingSession>(
@@ -234,7 +234,7 @@ bool BleV2Medium::StartScanning(const Uuid& service_uuid,
                                 ScanCallback callback) {
   LOG(INFO) << "G3 Ble StartScanning";
   auto internal_session_id = Prng().NextUint32();
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   MediumEnvironment::Instance().UpdateBleV2MediumForScanning(
       /*enabled=*/true, service_uuid, internal_session_id,
       {.advertisement_found_cb = std::move(callback.advertisement_found_cb)},
@@ -248,7 +248,7 @@ bool BleV2Medium::StartMultipleServicesScanning(
     api::ble_v2::TxPowerLevel tx_power_level, ScanCallback callback) {
   LOG(INFO) << "G3 Ble StartMultipleServicesScanning";
 
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   scan_callback_ = std::move(callback);
   for (const auto& service_uuid : service_uuids) {
     auto internal_session_id = Prng().NextUint32();
@@ -273,7 +273,7 @@ bool BleV2Medium::StartMultipleServicesScanning(
 
 bool BleV2Medium::StopScanning() {
   LOG(INFO) << "G3 Ble StopScanning";
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   for (auto element : scanning_internal_session_ids_) {
     MediumEnvironment::Instance().UpdateBleV2MediumForScanning(
         /*enabled=*/false,
@@ -291,7 +291,7 @@ std::unique_ptr<BleV2Medium::ScanningSession> BleV2Medium::StartScanning(
   auto internal_session_id = Prng().NextUint32();
 
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
 
     MediumEnvironment::Instance().UpdateBleV2MediumForScanning(
         /*enabled=*/true, service_uuid, internal_session_id,
@@ -302,7 +302,7 @@ std::unique_ptr<BleV2Medium::ScanningSession> BleV2Medium::StartScanning(
       .stop_scanning =
           [this, service_uuid = service_uuid,
            internal_session_id = internal_session_id]() {
-            absl::MutexLock lock(&mutex_);
+            absl::MutexLock lock(mutex_);
             if (scanning_internal_session_ids_.find(
                     {service_uuid, internal_session_id}) ==
                 scanning_internal_session_ids_.end()) {
@@ -370,7 +370,7 @@ BleV2Medium::GattServer::CreateCharacteristic(
     const Uuid& service_uuid, const Uuid& characteristic_uuid,
     api::ble_v2::GattCharacteristic::Permission permission,
     api::ble_v2::GattCharacteristic::Property property) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   api::ble_v2::GattCharacteristic characteristic = {
       .uuid = characteristic_uuid, .service_uuid = service_uuid};
   characteristics_[characteristic] = absl::NotFoundError("value not set");
@@ -379,7 +379,7 @@ BleV2Medium::GattServer::CreateCharacteristic(
 
 bool BleV2Medium::GattServer::DiscoverBleV2MediumGattCharacteristics(
     const Uuid& service_uuid, const std::vector<Uuid>& characteristic_uuids) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   auto contains = [&](const Uuid& characteristic_uuid) {
     return std::find(characteristic_uuids.begin(), characteristic_uuids.end(),
                      characteristic_uuid) != characteristic_uuids.end();
@@ -397,7 +397,7 @@ bool BleV2Medium::GattServer::DiscoverBleV2MediumGattCharacteristics(
 bool BleV2Medium::GattServer::UpdateCharacteristic(
     const api::ble_v2::GattCharacteristic& characteristic,
     const nearby::ByteArray& value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   LOG(INFO) << "G3 Ble GattServer UpdateCharacteristic, characteristic=("
             << characteristic.service_uuid.Get16BitAsString() << ","
             << std::string(characteristic.uuid)
@@ -409,7 +409,7 @@ bool BleV2Medium::GattServer::UpdateCharacteristic(
 absl::Status BleV2Medium::GattServer::NotifyCharacteristicChanged(
     const api::ble_v2::GattCharacteristic& characteristic, bool confirm,
     const ByteArray& new_value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   LOG(INFO) << "G3 Ble GattServer NotifyCharacteristicChanged, characteristic=("
             << characteristic.service_uuid.Get16BitAsString() << ","
             << std::string(characteristic.uuid)
@@ -430,7 +430,7 @@ absl::StatusOr<ByteArray> BleV2Medium::GattServer::ReadCharacteristic(
     const api::ble_v2::BlePeripheral::UniqueId remote_device_id,
     const api::ble_v2::GattCharacteristic& characteristic, int offset) {
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     const auto it = characteristics_.find(characteristic);
     if (it == characteristics_.end()) {
       return absl::FailedPreconditionError(
@@ -479,7 +479,7 @@ bool BleV2Medium::GattServer::AddCharacteristicSubscription(
     const api::ble_v2::BlePeripheral::UniqueId remote_device_id,
     const api::ble_v2::GattCharacteristic& characteristic,
     absl::AnyInvocable<void(absl::string_view value)> callback) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   const auto it = characteristics_.find(characteristic);
   if (it != characteristics_.end()) {
     subscribers_[SubscriberKey(remote_device_id, characteristic)] =
@@ -492,7 +492,7 @@ bool BleV2Medium::GattServer::AddCharacteristicSubscription(
 bool BleV2Medium::GattServer::RemoveCharacteristicSubscription(
     const api::ble_v2::BlePeripheral::UniqueId remote_device_id,
     const api::ble_v2::GattCharacteristic& characteristic) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   const auto it = characteristics_.find(characteristic);
   if (it != characteristics_.end()) {
     subscribers_.erase(SubscriberKey(remote_device_id, characteristic));
@@ -503,17 +503,17 @@ bool BleV2Medium::GattServer::RemoveCharacteristicSubscription(
 
 bool BleV2Medium::GattServer::HasCharacteristic(
     const api::ble_v2::GattCharacteristic& characteristic) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return characteristics_.find(characteristic) != characteristics_.end();
 }
 
 void BleV2Medium::GattServer::Connect(GattClient* client) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   connected_clients_.push_back(client);
 }
 
 void BleV2Medium::GattServer::Disconnect(GattClient* client) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   connected_clients_.erase(
       std::remove(connected_clients_.begin(), connected_clients_.end(), client),
       connected_clients_.end());
@@ -521,7 +521,7 @@ void BleV2Medium::GattServer::Disconnect(GattClient* client) {
 
 void BleV2Medium::GattServer::Stop() {
   if (stopped_) return;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   stopped_ = true;
   for (auto& client : connected_clients_) {
     client->OnServerDisconnected();
@@ -558,7 +558,7 @@ bool BleV2Medium::GattClient::DiscoverServiceAndCharacteristics(
   LOG(INFO)
       << "G3 Ble GattClient DiscoverServiceAndCharacteristics, service_uuid="
       << service_uuid.Get16BitAsString();
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (!is_connection_alive_) {
     return false;
   }
@@ -575,7 +575,7 @@ bool BleV2Medium::GattClient::DiscoverServiceAndCharacteristics(
 std::optional<api::ble_v2::GattCharacteristic>
 BleV2Medium::GattClient::GetCharacteristic(const Uuid& service_uuid,
                                            const Uuid& characteristic_uuid) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   LOG(INFO) << "G3 Ble GattClient GetCharacteristic, service_uuid="
             << service_uuid.Get16BitAsString()
             << ", characteristic_uuid=" << std::string(characteristic_uuid);
@@ -609,7 +609,7 @@ BleV2Medium::GattClient::GetCharacteristic(const Uuid& service_uuid,
 
 std::optional<std::string> BleV2Medium::GattClient::ReadCharacteristic(
     const api::ble_v2::GattCharacteristic& characteristic) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (!is_connection_alive_) {
     return std::nullopt;
   }
@@ -638,7 +638,7 @@ std::optional<std::string> BleV2Medium::GattClient::ReadCharacteristic(
 bool BleV2Medium::GattClient::WriteCharacteristic(
     const api::ble_v2::GattCharacteristic& characteristic,
     absl::string_view value, api::ble_v2::GattClient::WriteType write_type) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (!is_connection_alive_) {
     return false;
   }
@@ -665,7 +665,7 @@ bool BleV2Medium::GattClient::SetCharacteristicSubscription(
     const api::ble_v2::GattCharacteristic& characteristic, bool enable,
     absl::AnyInvocable<void(absl::string_view value)>
         on_characteristic_changed_cb) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (!is_connection_alive_) {
     return false;
   }
@@ -713,12 +713,12 @@ std::unique_ptr<api::ble_v2::BleServerSocket> BleV2Medium::OpenServerSocket(
     const std::string& service_id) {
   auto server_socket = std::make_unique<BleV2ServerSocket>(&GetAdapter());
   server_socket->SetCloseNotifier([this, service_id]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     server_sockets_.erase(service_id);
   });
   LOG(INFO) << "G3 Ble Adding server socket: medium=" << this
             << ", service_id=" << service_id;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   server_sockets_.insert({service_id, server_socket.get()});
   return server_socket;
 }
@@ -751,7 +751,7 @@ std::unique_ptr<api::ble_v2::BleSocket> BleV2Medium::Connect(
             << ", service_id=" << service_id;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&remote_medium->mutex_);
+    absl::MutexLock medium_lock(remote_medium->mutex_);
     auto item = remote_medium->server_sockets_.find(service_id);
     remote_server_socket =
         item != remote_medium->server_sockets_.end() ? item->second : nullptr;

internal/platform/implementation/g3/bluetooth_adapter.cc

@@ -86,7 +86,7 @@ bool BluetoothAdapter::SetStatus(Status status) {
   bool enabled = status == Status::kEnabled;
   std::string name;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     enabled_ = enabled;
     name = name_;
     mode = mode_;
@@ -97,12 +97,12 @@ bool BluetoothAdapter::SetStatus(Status status) {
 }
 
 bool BluetoothAdapter::IsEnabled() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return enabled_;
 }
 
 BluetoothAdapter::ScanMode BluetoothAdapter::GetScanMode() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return mode_;
 }
 
@@ -110,7 +110,7 @@ bool BluetoothAdapter::SetScanMode(BluetoothAdapter::ScanMode mode) {
   bool enabled;
   std::string name;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     mode_ = mode;
     name = name_;
     enabled = enabled_;
@@ -122,7 +122,7 @@ bool BluetoothAdapter::SetScanMode(BluetoothAdapter::ScanMode mode) {
 }
 
 std::string BluetoothAdapter::GetName() const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return name_;
 }
 
@@ -136,7 +136,7 @@ bool BluetoothAdapter::SetName(absl::string_view name,
   BluetoothAdapter::ScanMode mode;
   bool enabled;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     name_ = std::string(name);
     enabled = enabled_;
     mode = mode_;

internal/platform/implementation/g3/bluetooth_classic.cc

@@ -47,7 +47,7 @@ BluetoothDevice* BluetoothSocket::GetRemoteDevice() {
 }
 
 std::unique_ptr<api::BluetoothSocket> BluetoothServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -64,7 +64,7 @@ std::unique_ptr<api::BluetoothSocket> BluetoothServerSocket::Accept() {
 }
 
 bool BluetoothServerSocket::Connect(BluetoothSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR) << "Failed to connect to BT server socket: already connected";
@@ -82,17 +82,17 @@ bool BluetoothServerSocket::Connect(BluetoothSocket& socket) {
 
 void BluetoothServerSocket::SetCloseNotifier(
     absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 BluetoothServerSocket::~BluetoothServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception BluetoothServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -103,11 +103,11 @@ Exception BluetoothServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -199,7 +199,7 @@ std::unique_ptr<api::BluetoothSocket> BluetoothClassicMedium::ConnectToService(
             << ", uuid=" << service_uuid;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&medium->mutex_);
+    absl::MutexLock medium_lock(medium->mutex_);
     auto item = medium->sockets_.find(service_uuid);
     server_socket = item != medium->sockets_.end() ? item->second : nullptr;
     if (server_socket == nullptr) {
@@ -245,11 +245,11 @@ BluetoothClassicMedium::ListenForService(const std::string& service_name,
                                          const std::string& service_uuid) {
   auto socket = std::make_unique<BluetoothServerSocket>(GetAdapter());
   socket->SetCloseNotifier([this, uuid = service_uuid]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     sockets_.erase(uuid);
   });
   LOG(INFO) << "Adding service: medium=" << this << ", uuid=" << service_uuid;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   sockets_.emplace(service_uuid, socket.get());
   return socket;
 }

internal/platform/implementation/g3/preferences_manager.cc

@@ -44,58 +44,58 @@ PreferencesManager::PreferencesManager(FilePath preferences_dir) {
 }
 
 bool PreferencesManager::Set(absl::string_view key, const json& value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetValue(key, value);
 }
 
 bool PreferencesManager::SetBoolean(absl::string_view key, bool value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetValue(key, value);
 }
 
 bool PreferencesManager::SetInteger(absl::string_view key, int value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetValue(key, value);
 }
 
 bool PreferencesManager::SetInt64(absl::string_view key, int64_t value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetValue(key, value);
 }
 
 bool PreferencesManager::SetString(absl::string_view key,
                                    absl::string_view value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetValue(key, absl::StrCat(value));
 }
 
 bool PreferencesManager::SetBooleanArray(absl::string_view key,
                                          absl::Span<const bool> value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetArrayValue(key, value);
 }
 
 bool PreferencesManager::SetIntegerArray(absl::string_view key,
                                          absl::Span<const int> value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetArrayValue(key, value);
 }
 
 bool PreferencesManager::SetInt64Array(absl::string_view key,
                                        absl::Span<const int64_t> value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetArrayValue(key, value);
 }
 
 bool PreferencesManager::SetStringArray(absl::string_view key,
                                         absl::Span<const std::string> value) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return SetArrayValue(key, value);
 }
 
 bool PreferencesManager::SetTime(absl::string_view key, absl::Time value) {
   // Save time as nanos
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   int64_t tt = absl::ToUnixNanos(value);
   if (value_[absl::StrCat(key)] == tt) {
     return false;
@@ -108,61 +108,61 @@ bool PreferencesManager::SetTime(absl::string_view key, absl::Time value) {
 // Get JSON value.
 json PreferencesManager::Get(absl::string_view key,
                              const json& default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetValue(key, default_value);
 }
 
 bool PreferencesManager::GetBoolean(absl::string_view key,
                                     bool default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetValue(key, default_value);
 }
 
 int PreferencesManager::GetInteger(absl::string_view key,
                                    int default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetValue(key, default_value);
 }
 
 int64_t PreferencesManager::GetInt64(absl::string_view key,
                                      int64_t default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetValue(key, default_value);
 }
 
 std::string PreferencesManager::GetString(
     absl::string_view key, const std::string& default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetValue(key, default_value);
 }
 
 std::vector<bool> PreferencesManager::GetBooleanArray(
     absl::string_view key, absl::Span<const bool> default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetArrayValue(key, default_value);
 }
 
 std::vector<int> PreferencesManager::GetIntegerArray(
     absl::string_view key, absl::Span<const int> default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetArrayValue(key, default_value);
 }
 
 std::vector<int64_t> PreferencesManager::GetInt64Array(
     absl::string_view key, absl::Span<const int64_t> default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetArrayValue(key, default_value);
 }
 
 std::vector<std::string> PreferencesManager::GetStringArray(
     absl::string_view key, absl::Span<const std::string> default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return GetArrayValue(key, default_value);
 }
 
 absl::Time PreferencesManager::GetTime(absl::string_view key,
                                        absl::Time default_value) const {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   auto result = value_.find(absl::StrCat(key));
   if (result == value_.end()) {
     return default_value;
@@ -173,7 +173,7 @@ absl::Time PreferencesManager::GetTime(absl::string_view key,
 
 // Removes preferences
 void PreferencesManager::Remove(absl::string_view key) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   value_.erase(absl::StrCat(key));
 }
 

internal/platform/implementation/g3/scheduled_executor.cc

@@ -100,7 +100,7 @@ std::shared_ptr<api::Cancelable> ScheduledExecutor::Schedule(
       MediumEnvironment::Instance().GetSimulatedClock();
   if (fake_clock.has_value()) {
     absl::Time trigger_time = (*fake_clock)->Now() + delay;
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     tasks_.insert(std::pair<absl::Time, std::unique_ptr<Runnable>>(
         trigger_time, std::make_unique<Runnable>(std::move(task))));
   } else {
@@ -119,7 +119,7 @@ void ScheduledExecutor::RunReadyTasks() {
     return;
   }
   absl::Time current_time = (*fake_clock)->Now();
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   for (auto it = tasks_.begin(); it != tasks_.end();) {
     if (it->first <= current_time) {
       executor_.Execute(

internal/platform/implementation/g3/wifi_direct.cc

@@ -42,7 +42,7 @@ std::string WifiDirectServerSocket::GetName(absl::string_view ip_address,
 }
 
 std::unique_ptr<api::WifiDirectSocket> WifiDirectServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -60,7 +60,7 @@ std::unique_ptr<api::WifiDirectSocket> WifiDirectServerSocket::Accept() {
 }
 
 bool WifiDirectServerSocket::Connect(WifiDirectSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR)
@@ -79,17 +79,17 @@ bool WifiDirectServerSocket::Connect(WifiDirectSocket& socket) {
 
 void WifiDirectServerSocket::SetCloseNotifier(
     absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 WifiDirectServerSocket::~WifiDirectServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception WifiDirectServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -100,11 +100,11 @@ Exception WifiDirectServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -123,7 +123,7 @@ WifiDirectMedium::~WifiDirectMedium() {
 
 bool WifiDirectMedium::StartWifiDirect(
     WifiDirectCredentials* wifi_direct_credentials) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   std::string ssid = absl::StrCat("DIRECT-", Prng().NextUint32());
   wifi_direct_credentials->SetSSID(ssid);
@@ -141,7 +141,7 @@ bool WifiDirectMedium::StartWifiDirect(
 }
 
 bool WifiDirectMedium::StopWifiDirect() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   LOG(INFO) << "G3 StopWifiDirect GO";
 
   auto& env = MediumEnvironment::Instance();
@@ -153,7 +153,7 @@ bool WifiDirectMedium::StopWifiDirect() {
 
 bool WifiDirectMedium::ConnectWifiDirect(
     WifiDirectCredentials* wifi_direct_credentials) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   LOG(INFO) << "G3 ConnectWifiDirect : ssid="
             << wifi_direct_credentials->GetSSID()
@@ -176,7 +176,7 @@ bool WifiDirectMedium::ConnectWifiDirect(
 }
 
 bool WifiDirectMedium::DisconnectWifiDirect() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   LOG(INFO) << "G3 DisconnectWifiDirect";
 
@@ -206,7 +206,7 @@ std::unique_ptr<api::WifiDirectSocket> WifiDirectMedium::ConnectToService(
             << ", remote ip address + port=" << socket_name;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&remote_medium->mutex_);
+    absl::MutexLock medium_lock(remote_medium->mutex_);
     auto item = remote_medium->server_sockets_.find(socket_name);
     server_socket =
         item != remote_medium->server_sockets_.end() ? item->second : nullptr;
@@ -251,12 +251,12 @@ std::unique_ptr<api::WifiDirectServerSocket> WifiDirectMedium::ListenForService(
   std::string socket_name = WifiDirectServerSocket::GetName(
       server_socket->GetIPAddress(), server_socket->GetPort());
   server_socket->SetCloseNotifier([this, socket_name]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     server_sockets_.erase(socket_name);
   });
   LOG(INFO) << "G3 WifiDirect GO Adding server socket: medium=" << this
             << ", socket_name=" << socket_name;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   server_sockets_.insert({socket_name, server_socket.get()});
   return server_socket;
 }

internal/platform/implementation/g3/wifi_hotspot.cc

@@ -43,7 +43,7 @@ std::string WifiHotspotServerSocket::GetName(absl::string_view ip_address,
 }
 
 std::unique_ptr<api::WifiHotspotSocket> WifiHotspotServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -61,7 +61,7 @@ std::unique_ptr<api::WifiHotspotSocket> WifiHotspotServerSocket::Accept() {
 }
 
 bool WifiHotspotServerSocket::Connect(WifiHotspotSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR)
@@ -80,17 +80,17 @@ bool WifiHotspotServerSocket::Connect(WifiHotspotSocket& socket) {
 
 void WifiHotspotServerSocket::SetCloseNotifier(
     absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 WifiHotspotServerSocket::~WifiHotspotServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception WifiHotspotServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -101,11 +101,11 @@ Exception WifiHotspotServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -124,7 +124,7 @@ WifiHotspotMedium::~WifiHotspotMedium() {
 
 bool WifiHotspotMedium::StartWifiHotspot(
     HotspotCredentials* hotspot_credentials) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   if (!IsInterfaceValid()) return false;
 
@@ -145,7 +145,7 @@ bool WifiHotspotMedium::StartWifiHotspot(
 }
 
 bool WifiHotspotMedium::StopWifiHotspot() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   LOG(INFO) << "G3 StopWifiHotspot";
 
   if (!IsInterfaceValid()) return false;
@@ -159,7 +159,7 @@ bool WifiHotspotMedium::StopWifiHotspot() {
 
 bool WifiHotspotMedium::ConnectWifiHotspot(
     HotspotCredentials* hotspot_credentials) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   LOG(INFO) << "G3 ConnectWifiHotspot: ssid=" << hotspot_credentials->GetSSID()
             << ",  password:" << hotspot_credentials->GetPassword();
@@ -181,7 +181,7 @@ bool WifiHotspotMedium::ConnectWifiHotspot(
 }
 
 bool WifiHotspotMedium::DisconnectWifiHotspot() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
 
   LOG(INFO) << "G3 DisconnectWifiHotspot";
 
@@ -211,7 +211,7 @@ std::unique_ptr<api::WifiHotspotSocket> WifiHotspotMedium::ConnectToService(
             << remote_medium << ", remote ip address + port=" << socket_name;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&remote_medium->mutex_);
+    absl::MutexLock medium_lock(remote_medium->mutex_);
     auto item = remote_medium->server_sockets_.find(socket_name);
     server_socket =
         item != remote_medium->server_sockets_.end() ? item->second : nullptr;
@@ -268,12 +268,12 @@ WifiHotspotMedium::ListenForService(int port) {
   std::string socket_name = WifiHotspotServerSocket::GetName(
       server_socket->GetIPAddress(), server_socket->GetPort());
   server_socket->SetCloseNotifier([this, socket_name]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     server_sockets_.erase(socket_name);
   });
   LOG(INFO) << "G3 WifiHotspot Adding server socket: medium=" << this
             << ", socket_name=" << socket_name;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   server_sockets_.insert({socket_name, server_socket.get()});
   return server_socket;
 }

internal/platform/implementation/g3/wifi_lan.cc

@@ -49,7 +49,7 @@ std::string WifiLanServerSocket::GetName(const std::string& ip_address,
 }
 
 std::unique_ptr<api::WifiLanSocket> WifiLanServerSocket::Accept() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   while (!closed_ && pending_sockets_.empty()) {
     cond_.Wait(&mutex_);
   }
@@ -67,7 +67,7 @@ std::unique_ptr<api::WifiLanSocket> WifiLanServerSocket::Accept() {
 }
 
 bool WifiLanServerSocket::Connect(WifiLanSocket& socket) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   if (closed_) return false;
   if (socket.IsConnected()) {
     LOG(ERROR)
@@ -86,17 +86,17 @@ bool WifiLanServerSocket::Connect(WifiLanSocket& socket) {
 
 void WifiLanServerSocket::SetCloseNotifier(
     absl::AnyInvocable<void()> notifier) {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   close_notifier_ = std::move(notifier);
 }
 
 WifiLanServerSocket::~WifiLanServerSocket() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   DoClose();
 }
 
 Exception WifiLanServerSocket::Close() {
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   return DoClose();
 }
 
@@ -107,11 +107,11 @@ Exception WifiLanServerSocket::DoClose() {
     cond_.SignalAll();
     if (close_notifier_) {
       auto notifier = std::move(close_notifier_);
-      mutex_.Unlock();
+      mutex_.unlock();
       // Notifier may contain calls to public API, and may cause deadlock, if
       // mutex_ is held during the call.
       notifier();
-      mutex_.Lock();
+      mutex_.lock();
     }
   }
   return {Exception::kSuccess};
@@ -134,7 +134,7 @@ bool WifiLanMedium::StartAdvertising(const NsdServiceInfo& nsd_service_info) {
             << ", service_name=" << nsd_service_info.GetServiceName()
             << ", service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (advertising_info_.Existed(service_type)) {
       LOG(INFO)
           << "G3 WifiLan StartAdvertising: Can't start advertising because "
@@ -147,7 +147,7 @@ bool WifiLanMedium::StartAdvertising(const NsdServiceInfo& nsd_service_info) {
   env.UpdateWifiLanMediumForAdvertising(*this, nsd_service_info,
                                         /*enabled=*/true);
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     advertising_info_.Add(service_type);
   }
   return true;
@@ -160,7 +160,7 @@ bool WifiLanMedium::StopAdvertising(const NsdServiceInfo& nsd_service_info) {
             << ", service_name=" << nsd_service_info.GetServiceName()
             << ", service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!advertising_info_.Existed(service_type)) {
       LOG(INFO) << "G3 WifiLan StopAdvertising: Can't stop advertising because "
                    "we never started advertising for service_type="
@@ -179,7 +179,7 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_type,
                                    DiscoveredServiceCallback callback) {
   LOG(INFO) << "G3 WifiLan StartDiscovery: service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (discovering_info_.Existed(service_type)) {
       LOG(INFO) << "G3 WifiLan StartDiscovery: Can't start discovery because "
                    "service_type="
@@ -191,7 +191,7 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_type,
   env.UpdateWifiLanMediumForDiscovery(*this, std::move(callback), service_type,
                                       true);
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     discovering_info_.Add(service_type);
   }
   return true;
@@ -200,7 +200,7 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_type,
 bool WifiLanMedium::StopDiscovery(const std::string& service_type) {
   LOG(INFO) << "G3 WifiLan StopDiscovery: service_type=" << service_type;
   {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     if (!discovering_info_.Existed(service_type)) {
       LOG(INFO)
           << "G3 WifiLan StopDiscovery: Can't stop discovering because we "
@@ -243,7 +243,7 @@ std::unique_ptr<api::WifiLanSocket> WifiLanMedium::ConnectToService(
             << ", remote ip address + port=" << socket_name;
   // Then, find our server socket context in this medium.
   {
-    absl::MutexLock medium_lock(&remote_medium->mutex_);
+    absl::MutexLock medium_lock(remote_medium->mutex_);
     auto item = remote_medium->server_sockets_.find(socket_name);
     server_socket =
         item != remote_medium->server_sockets_.end() ? item->second : nullptr;
@@ -290,12 +290,12 @@ std::unique_ptr<api::WifiLanServerSocket> WifiLanMedium::ListenForService(
   std::string socket_name = WifiLanServerSocket::GetName(
       server_socket->GetIPAddress(), server_socket->GetPort());
   server_socket->SetCloseNotifier([this, socket_name]() {
-    absl::MutexLock lock(&mutex_);
+    absl::MutexLock lock(mutex_);
     server_sockets_.erase(socket_name);
   });
   LOG(INFO) << "G3 WifiLan Adding server socket: medium=" << this
             << ", socket_name=" << socket_name;
-  absl::MutexLock lock(&mutex_);
+  absl::MutexLock lock(mutex_);
   server_sockets_.insert({socket_name, server_socket.get()});
   return server_socket;
 }