grpc 1.84.1 → 1.85.0.pre1

data/src/core/channelz/channel_trace.cc

@@ -49,7 +49,7 @@ namespace channelz {
 Json ChannelTrace::RenderJson() const {
   if (max_memory_ == 0) return Json();
   Json::Array array;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   ForEachTraceEventLocked([&array](gpr_timespec timestamp, std::string line) {
     Json::Object object = {
         {"severity", Json::FromString("CT_INFO")},
@@ -77,7 +77,7 @@ std::string ChannelTrace::creation_timestamp() const {
 ChannelTrace::EntryRef ChannelTrace::AppendEntry(
     EntryRef parent, std::unique_ptr<Renderer> renderer) {
   if (max_memory_ == 0) return EntryRef::Sentinel();
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   ++num_events_logged_;
   const auto ref = NewEntry(parent, std::move(renderer));
   while (current_memory_ > max_memory_ && first_entry_ != kSentinelId) {
@@ -148,7 +148,7 @@ ChannelTrace::EntryRef ChannelTrace::NewEntry(
 
 void ChannelTrace::DropEntry(EntryRef entry) {
   if (entry.id == kSentinelId) return;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (entry.id >= entries_.size()) return;
   Entry& e = entries_[entry.id];
   if (e.salt != entry.salt) return;
@@ -205,7 +205,7 @@ void ChannelTrace::DropEntryId(uint16_t id) {
 
 void ChannelTrace::ForEachTraceEvent(
     absl::FunctionRef<void(gpr_timespec, std::string)> callback) const {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   ForEachTraceEventLocked(callback);
 }
 
@@ -242,7 +242,7 @@ void ChannelTrace::RenderEntry(
 
 void ChannelTrace::Render(grpc_channelz_v2_Entity* entity,
                           upb_Arena* arena) const {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   uint16_t id = first_entry_;
   while (id != kSentinelId) {
     const Entry& e = entries_[id];

data/src/core/channelz/channel_trace.h

@@ -291,7 +291,7 @@ class ChannelTrace {
 
   std::string creation_timestamp() const;
   uint64_t num_events_logged() const {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return num_events_logged_;
   }
 

data/src/core/channelz/channelz.cc

@@ -62,12 +62,12 @@ namespace channelz {
 
 void DataSinkImplementation::AddData(absl::string_view name,
                                      std::unique_ptr<Data> data) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   additional_info_.emplace_back(Element{std::string(name), std::move(data)});
 }
 
 Json::Array DataSinkImplementation::Finalize(bool) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   Json::Array out;
   for (auto& [name, additional_info] : additional_info_) {
     Json::Object obj;
@@ -81,7 +81,7 @@ Json::Array DataSinkImplementation::Finalize(bool) {
 void DataSinkImplementation::Finalize(bool timed_out,
                                       grpc_channelz_v2_Entity* entity,
                                       upb_Arena* arena) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_channelz_v2_Entity_set_timed_out(entity, timed_out);
   for (auto& [name, additional_info] : additional_info_) {
     auto* staple = grpc_channelz_v2_Entity_add_data(entity, arena);
@@ -129,7 +129,7 @@ Json::Array BaseNode::AdditionalInfo() {
   auto done = std::make_shared<Notification>();
   auto sink_impl = std::make_shared<DataSinkImplementation>();
   {
-    MutexLock lock(&data_sources_mu_);
+    MutexLock lock(data_sources_mu_);
     auto done_notifier = std::make_shared<DataSinkCompletionNotification>(
         [done]() { done->Notify(); });
     for (DataSource* data_source : data_sources_) {
@@ -153,7 +153,7 @@ std::unique_ptr<ZTrace> BaseNode::RunZTrace(
   };
   std::unique_ptr<ZTrace> ztrace;
   {
-    MutexLock lock(&data_sources_mu_);
+    MutexLock lock(data_sources_mu_);
     for (auto* data_source : data_sources_) {
       if (auto found_ztrace = data_source->GetZTrace(name);
           found_ztrace != nullptr) {
@@ -182,7 +182,7 @@ void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
       entity, StdStringToUpbString(EntityTypeToKind(type_)));
   std::vector<WeakRefCountedPtr<BaseNode>> parent_nodes;
   {
-    MutexLock lock(&parent_mu_);
+    MutexLock lock(parent_mu_);
     parent_nodes.assign(parents_.begin(), parents_.end());
   }
   auto* parents = grpc_channelz_v2_Entity_resize_parents(
@@ -201,7 +201,7 @@ void BaseNode::SerializeEntity(grpc_channelz_v2_Entity* entity,
   };
   AddNodeSpecificData(make_data_sink());
   {
-    MutexLock lock(&data_sources_mu_);
+    MutexLock lock(data_sources_mu_);
     for (DataSource* data_source : data_sources_) {
       data_source->AddData(make_data_sink());
     }
@@ -241,14 +241,14 @@ DataSource::~DataSource() {
 
 void DataSource::SourceConstructed() {
   if (node_ == nullptr) return;
-  MutexLock lock(&node_->data_sources_mu_);
+  MutexLock lock(node_->data_sources_mu_);
   node_->data_sources_.push_back(this);
 }
 
 void DataSource::SourceDestructing() {
   RefCountedPtr<BaseNode> node = std::move(node_);
   if (node == nullptr) return;
-  MutexLock lock(&node->data_sources_mu_);
+  MutexLock lock(node->data_sources_mu_);
   for (size_t i = 0; i < node->data_sources_.size(); ++i) {
     if (node->data_sources_[i] == this) {
       std::swap(node->data_sources_[i], node->data_sources_.back());

data/src/core/channelz/channelz.h

@@ -212,17 +212,17 @@ class BaseNode : public DualRefCounted<BaseNode> {
   void Orphaned() override;
 
   bool HasParent(const BaseNode* parent) const {
-    MutexLock lock(&parent_mu_);
+    MutexLock lock(parent_mu_);
     return parents_.find(parent) != parents_.end();
   }
 
   void AddParent(BaseNode* parent) {
-    MutexLock lock(&parent_mu_);
+    MutexLock lock(parent_mu_);
     parents_.insert(parent->WeakRef());
   }
 
   void RemoveParent(BaseNode* parent) {
-    MutexLock lock(&parent_mu_);
+    MutexLock lock(parent_mu_);
     parents_.erase(parent);
   }
 
@@ -504,7 +504,7 @@ class ChannelNode final : public BaseNode {
   void Orphaned() override {
     ChannelArgs to_destroy;
     {
-      MutexLock lock(&channel_args_mu_);
+      MutexLock lock(channel_args_mu_);
       std::swap(channel_args_, to_destroy);
     }
     BaseNode::Orphaned();
@@ -526,7 +526,7 @@ class ChannelNode final : public BaseNode {
   // proxy methods to composed classes.
   void SetChannelArgs(const ChannelArgs& channel_args) {
     ChannelArgs to_destroy;
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
@@ -542,7 +542,7 @@ class ChannelNode final : public BaseNode {
   std::set<intptr_t> child_channels() const;
   std::set<intptr_t> child_subchannels() const;
   ChannelArgs channel_args() const {
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     return channel_args_;
   }
 
@@ -571,7 +571,7 @@ class SubchannelNode final : public BaseNode {
   void Orphaned() override {
     ChannelArgs to_destroy;
     {
-      MutexLock lock(&channel_args_mu_);
+      MutexLock lock(channel_args_mu_);
       std::swap(channel_args_, to_destroy);
     }
     BaseNode::Orphaned();
@@ -585,7 +585,7 @@ class SubchannelNode final : public BaseNode {
   // proxy methods to composed classes.
   void SetChannelArgs(const ChannelArgs& channel_args) {
     ChannelArgs to_destroy;
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
@@ -597,7 +597,7 @@ class SubchannelNode final : public BaseNode {
   std::string connectivity_state() const;
   CallCounts GetCallCounts() const { return call_counter_.GetCallCounts(); }
   ChannelArgs channel_args() const {
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     return channel_args_;
   }
 
@@ -626,7 +626,7 @@ class ServerNode final : public BaseNode {
   void Orphaned() override {
     ChannelArgs to_destroy;
     {
-      MutexLock lock(&channel_args_mu_);
+      MutexLock lock(channel_args_mu_);
       std::swap(channel_args_, to_destroy);
     }
     BaseNode::Orphaned();
@@ -640,7 +640,7 @@ class ServerNode final : public BaseNode {
   // proxy methods to composed classes.
   void SetChannelArgs(const ChannelArgs& channel_args) {
     ChannelArgs to_destroy;
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     std::swap(channel_args_, to_destroy);
     channel_args_ = channel_args;
   }
@@ -655,7 +655,7 @@ class ServerNode final : public BaseNode {
   std::map<intptr_t, WeakRefCountedPtr<SocketNode>> child_sockets() const;
 
   ChannelArgs channel_args() const {
-    MutexLock lock(&channel_args_mu_);
+    MutexLock lock(channel_args_mu_);
     return channel_args_;
   }
 

data/src/core/channelz/channelz_registry.cc

@@ -70,7 +70,7 @@ void ChannelzRegistry::InternalRegister(BaseNode* node) {
   DCHECK_EQ(node->uuid_, -1);
   const size_t node_shard_index = NodeShardIndex(node);
   NodeShard& node_shard = node_shards_[node_shard_index];
-  MutexLock lock(&node_shard.mu);
+  MutexLock lock(node_shard.mu);
   node_shard.nursery.AddToHead(node);
 }
 
@@ -87,7 +87,7 @@ void ChannelzRegistry::InternalUnregister(BaseNode* node) {
     // if necessary, then exit out.
     node_shard.mu.Unlock();
     if (uuid != -1) {
-      MutexLock lock(&index_mu_);
+      MutexLock lock(index_mu_);
       index_.erase(uuid);
     }
     return;
@@ -128,7 +128,7 @@ void ChannelzRegistry::InternalUnregister(BaseNode* node) {
   WeakRefCountedPtr<BaseNode> gcd_node(n);
   node_shard.mu.Unlock();
   if (gc_list == &node_shard.orphaned_numbered) {
-    MutexLock lock(&index_mu_);
+    MutexLock lock(index_mu_);
     intptr_t uuid = n->uuid_.load(std::memory_order_relaxed);
     index_.erase(uuid);
   }
@@ -164,7 +164,7 @@ ChannelzRegistry::QueryNodes(
   // after releasing the lock.
   WeakRefCountedPtr<BaseNode> node_after_end;
   std::vector<WeakRefCountedPtr<BaseNode>> result;
-  MutexLock index_lock(&index_mu_);
+  MutexLock index_lock(index_mu_);
   for (auto it = index_.lower_bound(start_node); it != index_.end(); ++it) {
     BaseNode* node = it->second;
     if (!discriminator(node)) continue;
@@ -178,7 +178,7 @@ ChannelzRegistry::QueryNodes(
   }
   for (auto nursery_index : nursery_visitation_order) {
     NodeShard& node_shard = node_shards_[nursery_index];
-    MutexLock shard_lock(&node_shard.mu);
+    MutexLock shard_lock(node_shard.mu);
     for (auto [nursery, numbered] :
          {std::pair(&node_shard.nursery, &node_shard.numbered),
           std::pair(&node_shard.orphaned, &node_shard.orphaned_numbered)}) {
@@ -216,7 +216,7 @@ ChannelzRegistry::QueryNodes(
 }
 
 WeakRefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
-  MutexLock index_lock(&index_mu_);
+  MutexLock index_lock(index_mu_);
   auto it = index_.find(uuid);
   if (it == index_.end()) return nullptr;
   BaseNode* node = it->second;
@@ -229,8 +229,8 @@ intptr_t ChannelzRegistry::InternalNumberNode(BaseNode* node) {
   if (strong_node == nullptr) return 0;
   const size_t node_shard_index = NodeShardIndex(node);
   NodeShard& node_shard = node_shards_[node_shard_index];
-  MutexLock index_lock(&index_mu_);
-  MutexLock lock(&node_shard.mu);
+  MutexLock index_lock(index_mu_);
+  MutexLock lock(node_shard.mu);
   intptr_t uuid = node->uuid_.load(std::memory_order_relaxed);
   if (uuid != -1) return uuid;
   uuid = uuid_generator_;
@@ -295,7 +295,7 @@ void ChannelzRegistry::TestOnlyReset() {
   p->LoadConfig();
   std::vector<WeakRefCountedPtr<BaseNode>> free_nodes;
   for (size_t i = 0; i < kNodeShards; i++) {
-    MutexLock lock(&p->node_shards_[i].mu);
+    MutexLock lock(p->node_shards_[i].mu);
     CHECK(p->node_shards_[i].nursery.head == nullptr);
     CHECK(p->node_shards_[i].numbered.head == nullptr);
     while (p->node_shards_[i].orphaned.head != nullptr) {
@@ -310,7 +310,7 @@ void ChannelzRegistry::TestOnlyReset() {
   }
   std::vector<NodeShard> replace_node_shards(kNodeShards);
   replace_node_shards.swap(p->node_shards_);
-  MutexLock lock(&p->index_mu_);
+  MutexLock lock(p->index_mu_);
   p->index_.clear();
 }
 

data/src/core/channelz/ztrace_collector.h

@@ -203,7 +203,7 @@ class ZTraceCollector {
   bool IsActive() {
     if (!impl_.is_set()) return false;
     auto impl = impl_.Get();
-    MutexLock lock(&impl->mu);
+    MutexLock lock(impl->mu);
     return !impl->instances.empty();
   }
 
@@ -388,7 +388,7 @@ class ZTraceCollector {
 
     ~ZTraceImpl() override {
       if (instance_ != nullptr) {
-        MutexLock lock(&impl_->mu);
+        MutexLock lock(impl_->mu);
         instance_->Finish(absl::CancelledError());
       }
     }
@@ -400,7 +400,7 @@ class ZTraceCollector {
       CHECK(instance_ == nullptr);
       instance_ = MakeRefCounted<Instance>(std::move(args), event_engine);
       RefCountedPtr<Instance> oldest_instance;
-      MutexLock lock(&impl_->mu);
+      MutexLock lock(impl_->mu);
       if (impl_->instances.size() > 20) {
         // Eject oldest running trace
         Timestamp oldest_time = Timestamp::InfFuture();
@@ -430,7 +430,7 @@ class ZTraceCollector {
         const bool end =
             (response.ok() && !response->has_value()) || !response.ok();
         (*callback)(std::move(response));
-        MutexLock lock(&impl->mu);
+        MutexLock lock(impl->mu);
         if (end) {
           impl->instances.erase(instance);
         } else {
@@ -449,7 +449,7 @@ class ZTraceCollector {
     auto value = std::pair(gpr_get_cycle_counter(), std::forward<T>(data));
     auto* impl = impl_.Get();
     {
-      MutexLock lock(&impl->mu);
+      MutexLock lock(impl->mu);
       switch (impl->instances.size()) {
         case 0:
           return;

data/src/core/client_channel/client_channel.cc

@@ -718,7 +718,7 @@ class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
                        Timestamp deadline)
       : channel_(std::move(channel)), cq_(cq), tag_(tag) {
     grpc_cq_begin_op(cq, tag);
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // Start watch.  This inherits the ref from creation.
     auto watcher =
         MakeOrphanable<Watcher>(RefCountedPtr<ExternalStateWatcher>(this));
@@ -756,7 +756,7 @@ class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
   // on the first call.  Subsequent calls will be ignored, because
   // events can come in asynchronously.
   void MaybeStartCompletion(absl::Status status) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (watcher_ == nullptr) return;  // Ignore subsequent notifications.
     // Cancel watch.
     channel_->RemoveConnectivityWatcher(watcher_);
@@ -818,7 +818,7 @@ void ClientChannel::RemoveConnectivityWatcher(
 }
 
 void ClientChannel::GetInfo(const grpc_channel_info* info) {
-  MutexLock lock(&info_mu_);
+  MutexLock lock(info_mu_);
   if (info->lb_policy_name != nullptr) {
     *info->lb_policy_name = gpr_strdup(info_lb_policy_name_.c_str());
   }
@@ -1345,7 +1345,7 @@ void ClientChannel::UpdateServiceConfigInControlPlaneLocked(
   saved_config_selector_ = std::move(config_selector);
   // Update the data used by GetChannelInfo().
   {
-    MutexLock lock(&info_mu_);
+    MutexLock lock(info_mu_);
     info_lb_policy_name_ = std::move(lb_policy_name);
     info_service_config_json_ = std::move(service_config_json);
   }

data/src/core/client_channel/client_channel_filter.cc

@@ -683,7 +683,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
                                          chand_->interested_parties_);
   GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "ExternalConnectivityWatcher");
   {
-    MutexLock lock(&chand_->external_watchers_mu_);
+    MutexLock lock(chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
     GRPC_CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
@@ -713,7 +713,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::
                                          bool cancel) {
   RefCountedPtr<ExternalConnectivityWatcher> watcher;
   {
-    MutexLock lock(&chand->external_watchers_mu_);
+    MutexLock lock(chand->external_watchers_mu_);
     auto it = chand->external_watchers_.find(on_complete);
     if (it != chand->external_watchers_.end()) {
       watcher = std::move(it->second);
@@ -1299,7 +1299,7 @@ void ClientChannelFilter::OnResolverErrorLocked(absl::Status status) {
     UpdateStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
                       "resolver failure");
     {
-      MutexLock lock(&resolution_mu_);
+      MutexLock lock(resolution_mu_);
       // Update resolver transient failure.
       resolver_transient_failure_error_ =
           MaybeRewriteIllegalStatusCode(status, "resolver");
@@ -1375,7 +1375,7 @@ void ClientChannelFilter::UpdateServiceConfigInControlPlaneLocked(
   saved_service_config_ = std::move(service_config);
   // Swap out the data used by GetChannelInfo().
   {
-    MutexLock lock(&info_mu_);
+    MutexLock lock(info_mu_);
     info_lb_policy_name_ = std::move(lb_policy_name);
     info_service_config_json_ = std::move(service_config_json);
   }
@@ -1451,7 +1451,7 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
   // We defer unreffing the old values (and deallocating memory) until
   // after releasing the lock to keep the critical section small.
   {
-    MutexLock lock(&resolution_mu_);
+    MutexLock lock(resolution_mu_);
     resolver_transient_failure_error_ = absl::OkStatus();
     // Update service config.
     received_service_config_data_ = true;
@@ -1496,7 +1496,7 @@ void ClientChannelFilter::DestroyResolverAndLbPolicyLocked() {
     RefCountedPtr<ServiceConfig> service_config_to_unref;
     RefCountedPtr<ConfigSelector> config_selector_to_unref;
     {
-      MutexLock lock(&resolution_mu_);
+      MutexLock lock(resolution_mu_);
       received_service_config_data_ = false;
       service_config_to_unref = std::move(service_config_);
       config_selector_to_unref = std::move(config_selector_);
@@ -1544,7 +1544,7 @@ void ClientChannelFilter::UpdateStateAndPickerLocked(
   // Grab the LB lock to update the picker and trigger reprocessing of the
   // queued picks.
   // Old picker will be unreffed after releasing the lock.
-  MutexLock lock(&lb_mu_);
+  MutexLock lock(lb_mu_);
   picker_.swap(picker);
   // Reprocess queued picks.
   for (auto& call : lb_queued_calls_) {
@@ -1594,7 +1594,7 @@ grpc_error_handle ClientChannelFilter::DoPingLocked(grpc_transport_op* op) {
   }
   LoadBalancingPolicy::PickResult result;
   {
-    MutexLock lock(&lb_mu_);
+    MutexLock lock(lb_mu_);
     result = picker_->Pick(LoadBalancingPolicy::PickArgs());
   }
   return HandlePickResult<grpc_error_handle>(
@@ -1699,7 +1699,7 @@ void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
 void ClientChannelFilter::GetChannelInfo(grpc_channel_element* elem,
                                          const grpc_channel_info* info) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  MutexLock lock(&chand->info_mu_);
+  MutexLock lock(chand->info_mu_);
   if (info->lb_policy_name != nullptr) {
     *info->lb_policy_name = gpr_strdup(chand->info_lb_policy_name_.c_str());
   }
@@ -1767,7 +1767,7 @@ class ClientChannelFilter::CallData::ResolverQueuedCallCanceller final {
     auto* calld = self->calld_;
     auto* chand = calld->chand();
     {
-      MutexLock lock(&chand->resolution_mu_);
+      MutexLock lock(chand->resolution_mu_);
       GRPC_TRACE_LOG(client_channel_call, INFO)
           << "chand=" << chand << " calld=" << calld
           << ": cancelling resolver queued pick: "
@@ -1873,7 +1873,7 @@ std::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
   // Check if we have a resolver result to use.
   absl::StatusOr<RefCountedPtr<ConfigSelector>> config_selector;
   {
-    MutexLock lock(&chand()->resolution_mu_);
+    MutexLock lock(chand()->resolution_mu_);
     bool result_ready = CheckResolutionLocked(&config_selector);
     // If no result is available, queue the call.
     if (!result_ready) {
@@ -2239,7 +2239,7 @@ class ClientChannelFilter::LoadBalancedCall::LbQueuedCallCanceller final {
     auto* lb_call = self->lb_call_.get();
     auto* chand = lb_call->chand_;
     {
-      MutexLock lock(&chand->lb_mu_);
+      MutexLock lock(chand->lb_mu_);
       GRPC_TRACE_LOG(client_channel_lb_call, INFO)
           << "chand=" << chand << " lb_call=" << lb_call
           << ": cancelling queued pick: error=" << StatusToString(error)
@@ -2393,7 +2393,7 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
       << "chand=" << chand_ << " lb_call=" << this
       << ": grabbing LB mutex to get picker";
   {
-    MutexLock lock(&chand_->lb_mu_);
+    MutexLock lock(chand_->lb_mu_);
     picker = chand_->picker_;
   }
   while (true) {
@@ -2413,7 +2413,7 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     bool pick_complete = PickSubchannelImpl(picker.get(), &error);
     if (!pick_complete) {
       RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> old_picker;
-      MutexLock lock(&chand_->lb_mu_);
+      MutexLock lock(chand_->lb_mu_);
       // If picker has been swapped out since we grabbed it, try again.
       if (picker != chand_->picker_) {
         GRPC_TRACE_LOG(client_channel_lb_call, INFO)

data/src/core/client_channel/global_subchannel_pool.cc

@@ -38,7 +38,7 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
   auto& read_shard = read_shards_[shard_index];
   SubchannelMap old_map1;
   SubchannelMap old_map2;
-  MutexLock lock(&write_shard.mu);
+  MutexLock lock(write_shard.mu);
   auto* existing = write_shard.map.Lookup(key);
   if (existing != nullptr) {
     auto existing_ref = (*existing)->RefIfNonZero();
@@ -46,7 +46,7 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
   }
   old_map1 = std::exchange(write_shard.map,
                            write_shard.map.Add(key, constructed->WeakRef()));
-  MutexLock lock_read(&read_shard.mu);
+  MutexLock lock_read(read_shard.mu);
   old_map2 = std::exchange(read_shard.map, write_shard.map);
   return constructed;
 }
@@ -58,13 +58,13 @@ void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   auto& read_shard = read_shards_[shard_index];
   SubchannelMap old_map1;
   SubchannelMap old_map2;
-  MutexLock lock(&write_shard.mu);
+  MutexLock lock(write_shard.mu);
   auto* existing = write_shard.map.Lookup(key);
   // delete only if key hasn't been re-registered to a different subchannel
   // between strong-unreffing and unregistration of subchannel.
   if (existing == nullptr || existing->get() != subchannel) return;
   old_map1 = std::exchange(write_shard.map, write_shard.map.Remove(key));
-  MutexLock lock_read(&read_shard.mu);
+  MutexLock lock_read(read_shard.mu);
   old_map2 = std::exchange(read_shard.map, write_shard.map);
 }