From 91721c3dbb88d9ccc525dbe7fa49d815e6eca6ca Mon Sep 17 00:00:00 2001 From: hai007 Date: Sun, 31 Aug 2025 14:37:16 -0700 Subject: [PATCH] Automated Code Change PiperOrigin-RevId: 801577756 --- internal/platform/implementation/g3/awdl.cc | 32 ++++----- internal/platform/implementation/g3/ble.cc | 26 +++---- internal/platform/implementation/g3/ble_v2.cc | 68 +++++++++---------- .../implementation/g3/bluetooth_adapter.cc | 12 ++-- .../implementation/g3/bluetooth_classic.cc | 20 +++--- .../implementation/g3/preferences_manager.cc | 42 ++++++------ .../implementation/g3/scheduled_executor.cc | 4 +- .../platform/implementation/g3/wifi_direct.cc | 28 ++++---- .../implementation/g3/wifi_hotspot.cc | 28 ++++---- .../platform/implementation/g3/wifi_lan.cc | 32 ++++----- 10 files changed, 146 insertions(+), 146 deletions(-) diff --git a/internal/platform/implementation/g3/awdl.cc b/internal/platform/implementation/g3/awdl.cc index 73816db8..421da0f7 100644 --- a/internal/platform/implementation/g3/awdl.cc +++ b/internal/platform/implementation/g3/awdl.cc @@ -50,7 +50,7 @@ std::string AwdlServerSocket::GetName(const std::string& ip_address, int port) { } std::unique_ptr 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 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 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 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 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; } diff --git a/internal/platform/implementation/g3/ble.cc b/internal/platform/implementation/g3/ble.cc index e847f3a3..a6b6dec9 100644 --- a/internal/platform/implementation/g3/ble.cc +++ b/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 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 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 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(); @@ -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 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) diff --git a/internal/platform/implementation/g3/ble_v2.cc b/internal/platform/implementation/g3/ble_v2.cc index c6d4f2a5..46453588 100644 --- a/internal/platform/implementation/g3/ble_v2.cc +++ b/internal/platform/implementation/g3/ble_v2.cc @@ -82,7 +82,7 @@ api::ble_v2::BlePeripheral::UniqueId BleV2Socket::GetRemotePeripheralId() { } std::unique_ptr 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 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 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::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( @@ -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::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::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& 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 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 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 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 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 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 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 BleV2Medium::OpenServerSocket( const std::string& service_id) { auto server_socket = std::make_unique(&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 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; diff --git a/internal/platform/implementation/g3/bluetooth_adapter.cc b/internal/platform/implementation/g3/bluetooth_adapter.cc index 2d86c3b5..4746201a 100644 --- a/internal/platform/implementation/g3/bluetooth_adapter.cc +++ b/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_; diff --git a/internal/platform/implementation/g3/bluetooth_classic.cc b/internal/platform/implementation/g3/bluetooth_classic.cc index c247299a..0095fb99 100644 --- a/internal/platform/implementation/g3/bluetooth_classic.cc +++ b/internal/platform/implementation/g3/bluetooth_classic.cc @@ -47,7 +47,7 @@ BluetoothDevice* BluetoothSocket::GetRemoteDevice() { } std::unique_ptr 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 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 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 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(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; } diff --git a/internal/platform/implementation/g3/preferences_manager.cc b/internal/platform/implementation/g3/preferences_manager.cc index 74461d27..67d89aab 100644 --- a/internal/platform/implementation/g3/preferences_manager.cc +++ b/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 value) { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return SetArrayValue(key, value); } bool PreferencesManager::SetIntegerArray(absl::string_view key, absl::Span value) { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return SetArrayValue(key, value); } bool PreferencesManager::SetInt64Array(absl::string_view key, absl::Span value) { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return SetArrayValue(key, value); } bool PreferencesManager::SetStringArray(absl::string_view key, absl::Span 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 PreferencesManager::GetBooleanArray( absl::string_view key, absl::Span default_value) const { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return GetArrayValue(key, default_value); } std::vector PreferencesManager::GetIntegerArray( absl::string_view key, absl::Span default_value) const { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return GetArrayValue(key, default_value); } std::vector PreferencesManager::GetInt64Array( absl::string_view key, absl::Span default_value) const { - absl::MutexLock lock(&mutex_); + absl::MutexLock lock(mutex_); return GetArrayValue(key, default_value); } std::vector PreferencesManager::GetStringArray( absl::string_view key, absl::Span 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)); } diff --git a/internal/platform/implementation/g3/scheduled_executor.cc b/internal/platform/implementation/g3/scheduled_executor.cc index b23ef77a..f82d6f7b 100644 --- a/internal/platform/implementation/g3/scheduled_executor.cc +++ b/internal/platform/implementation/g3/scheduled_executor.cc @@ -100,7 +100,7 @@ std::shared_ptr 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>( trigger_time, std::make_unique(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( diff --git a/internal/platform/implementation/g3/wifi_direct.cc b/internal/platform/implementation/g3/wifi_direct.cc index 634060ec..be911626 100644 --- a/internal/platform/implementation/g3/wifi_direct.cc +++ b/internal/platform/implementation/g3/wifi_direct.cc @@ -42,7 +42,7 @@ std::string WifiDirectServerSocket::GetName(absl::string_view ip_address, } std::unique_ptr 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 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 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 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 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; } diff --git a/internal/platform/implementation/g3/wifi_hotspot.cc b/internal/platform/implementation/g3/wifi_hotspot.cc index 782c4365..e8793501 100644 --- a/internal/platform/implementation/g3/wifi_hotspot.cc +++ b/internal/platform/implementation/g3/wifi_hotspot.cc @@ -43,7 +43,7 @@ std::string WifiHotspotServerSocket::GetName(absl::string_view ip_address, } std::unique_ptr 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 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 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 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; } diff --git a/internal/platform/implementation/g3/wifi_lan.cc b/internal/platform/implementation/g3/wifi_lan.cc index c09fb7b9..56c19ed6 100644 --- a/internal/platform/implementation/g3/wifi_lan.cc +++ b/internal/platform/implementation/g3/wifi_lan.cc @@ -49,7 +49,7 @@ std::string WifiLanServerSocket::GetName(const std::string& ip_address, } std::unique_ptr 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 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 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 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 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; }