grpc 1.84.0 → 1.85.0.pre1

data/src/core/call/metadata_batch.h

@@ -342,6 +342,16 @@ struct XEnvoyPeerMetadata : public SimpleSliceBasedMetadata {
   static absl::string_view key() { return "x-envoy-peer-metadata"; }
 };
 
+// x-envoy-auth-failure-mode-allowed metadata trait for ext_authz failure mode
+// allow.
+struct XEnvoyAuthFailureModeAllowedMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kPublishToApp = true;
+  static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
+  using CompressionTraits = StableValueCompressor;
+  static absl::string_view key() { return "x-envoy-auth-failure-mode-allowed"; }
+};
+
 // x-forwarded-for metadata trait for HTTP connect.
 struct XForwardedForMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kPublishToApp = true;
@@ -722,7 +732,7 @@ template <typename MustBeVoid, typename... Traits>
 struct EncodableTraits;
 
 template <typename Trait, typename... Traits>
-struct EncodableTraits<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
+struct EncodableTraits<std::enable_if_t<IsEncodableTrait<Trait>::value, void>,
                        Trait, Traits...> {
   using List =
       typename EncodableTraits<void,
@@ -730,7 +740,7 @@ struct EncodableTraits<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
 };
 
 template <typename Trait, typename... Traits>
-struct EncodableTraits<absl::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
+struct EncodableTraits<std::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
                        Trait, Traits...> {
   using List = typename EncodableTraits<void, Traits...>::List;
 };
@@ -883,7 +893,7 @@ class GetStringValueHelper {
       : container_(container), backing_(backing) {}
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == false &&
           std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -894,7 +904,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == true &&
           std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -910,7 +920,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == true &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -927,7 +937,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == false &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -1003,9 +1013,9 @@ template <typename Which, typename Ignored = void>
 struct Value;
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
-                                          IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == false &&
+                                         IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) : value(value) {}
   explicit Value(typename Which::ValueType&& value)
@@ -1034,9 +1044,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
-                                          !IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == false &&
+                                         !IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) : value(value) {}
   explicit Value(typename Which::ValueType&& value)
@@ -1063,9 +1073,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
-                                          IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == true &&
+                                         IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) {
     this->value.push_back(value);
@@ -1101,9 +1111,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
-                                          !IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == true &&
+                                         !IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) {
     this->value.push_back(value);
@@ -1199,13 +1209,13 @@ struct FilterWrapper {
   Filterer filter_fn;
 
   template <typename Which,
-            absl::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
+            std::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
   bool operator()(const Value<Which>& /*which*/) {
     return filter_fn(Which());
   }
 
   template <typename Which,
-            absl::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
+            std::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
   bool operator()(const Value<Which>& /*which*/) {
     return true;
   }
@@ -1306,14 +1316,14 @@ struct StatefulCompressor<Factory> {};
 // Helper function for encoders
 // Given a metadata trait, convert the value to a slice.
 template <typename Which>
-absl::enable_if_t<std::is_same<typename Which::ValueType, Slice>::value,
-                  const Slice&>
+std::enable_if_t<std::is_same<typename Which::ValueType, Slice>::value,
+                 const Slice&>
 MetadataValueAsSlice(const Slice& slice) {
   return slice;
 }
 
 template <typename Which>
-absl::enable_if_t<!std::is_same<typename Which::ValueType, Slice>::value, Slice>
+std::enable_if_t<!std::is_same<typename Which::ValueType, Slice>::value, Slice>
 MetadataValueAsSlice(typename Which::ValueType value) {
   return Slice(Which::Encode(value));
 }
@@ -1580,13 +1590,13 @@ class MetadataMap {
   // Set the value of some known metadata.
   // Returns a pointer to the new value.
   template <typename Which, typename... Args>
-  absl::enable_if_t<Which::kRepeatable == false, void> Set(Which,
-                                                           Args&&... args) {
+  std::enable_if_t<Which::kRepeatable == false, void> Set(Which,
+                                                          Args&&... args) {
     table_.template set<Value<Which>>(std::forward<Args>(args)...);
   }
   template <typename Which, typename... Args>
-  absl::enable_if_t<Which::kRepeatable == true, void> Set(Which,
-                                                          Args&&... args) {
+  std::enable_if_t<Which::kRepeatable == true, void> Set(Which,
+                                                         Args&&... args) {
     GetOrCreatePointer(Which())->emplace_back(std::forward<Args>(args)...);
   }
 
@@ -1618,8 +1628,8 @@ class MetadataMap {
   //  auto value = m.get(T());
   //  m.Remove(T());
   template <typename Which>
-  absl::enable_if_t<Which::kRepeatable == false,
-                    std::optional<typename Which::ValueType>>
+  std::enable_if_t<Which::kRepeatable == false,
+                   std::optional<typename Which::ValueType>>
   Take(Which which) {
     if (auto* p = get_pointer(which)) {
       std::optional<typename Which::ValueType> value(std::move(*p));
@@ -1632,8 +1642,8 @@ class MetadataMap {
   // Extract repeated known metadata.
   // Returns an empty vector if the metadata was not present.
   template <typename Which>
-  absl::enable_if_t<Which::kRepeatable == true,
-                    typename metadata_detail::Value<Which>::StorageType>
+  std::enable_if_t<Which::kRepeatable == true,
+                   typename metadata_detail::Value<Which>::StorageType>
   Take(Which which) {
     if (auto* p = get_pointer(which)) {
       typename Value<Which>::StorageType value = std::move(*p);
@@ -1757,8 +1767,10 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
-    grpc_core::XEnvoyPeerMetadata, grpc_core::XForwardedForMetadata,
-    grpc_core::XForwardedHostMetadata, grpc_core::W3CTraceParentMetadata,
+    grpc_core::XEnvoyPeerMetadata,
+    grpc_core::XEnvoyAuthFailureModeAllowedMetadata,
+    grpc_core::XForwardedForMetadata, grpc_core::XForwardedHostMetadata,
+    grpc_core::W3CTraceParentMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::LbPolicyDrop,
     grpc_core::PeerString, grpc_core::GrpcStatusContext,

data/src/core/call/parsed_metadata.h

@@ -120,8 +120,8 @@ class ParsedMetadata {
   template <typename Which>
   ParsedMetadata(
       Which,
-      absl::enable_if_t<metadata_detail::HasSimpleMemento<Which>::value,
-                        typename Which::MementoType>
+      std::enable_if_t<metadata_detail::HasSimpleMemento<Which>::value,
+                       typename Which::MementoType>
           value,
       uint32_t transport_size)
       : vtable_(ParsedMetadata::template TrivialTraitVTable<Which>()),
@@ -131,7 +131,7 @@ class ParsedMetadata {
   template <typename Which>
   ParsedMetadata(
       Which,
-      absl::enable_if_t<
+      std::enable_if_t<
           !metadata_detail::HasSimpleMemento<Which>::value &&
               !std::is_convertible<typename Which::MementoType, Slice>::value,
           typename Which::MementoType>

data/src/core/call/request_buffer.cc

@@ -28,7 +28,7 @@ RequestBuffer::RequestBuffer() : state_(absl::in_place_type_t<Buffering>()) {}
 
 ValueOrFailure<size_t> RequestBuffer::PushClientInitialMetadata(
     ClientMetadataHandle md) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   auto& buffering = std::get<Buffering>(state_);
   CHECK_EQ(buffering.initial_metadata.get(), nullptr);
@@ -40,7 +40,7 @@ ValueOrFailure<size_t> RequestBuffer::PushClientInitialMetadata(
 
 Poll<ValueOrFailure<size_t>> RequestBuffer::PollPushMessage(
     MessageHandle& message) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   size_t buffered = 0;
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
@@ -61,7 +61,7 @@ Poll<ValueOrFailure<size_t>> RequestBuffer::PollPushMessage(
 }
 
 StatusFlag RequestBuffer::FinishSends() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
     Buffered buffered(std::move(buffering->initial_metadata),
@@ -77,14 +77,14 @@ StatusFlag RequestBuffer::FinishSends() {
 }
 
 void RequestBuffer::Cancel(absl::Status error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::holds_alternative<Cancelled>(state_)) return;
   state_.emplace<Cancelled>(std::move(error));
   WakeupAsyncAllPullers();
 }
 
 void RequestBuffer::Commit(Reader* winner) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   CHECK_EQ(winner_, nullptr);
   winner_ = winner;
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
@@ -111,7 +111,7 @@ void RequestBuffer::WakeupAsyncAllPullersExcept(Reader* except_reader) {
 
 Poll<ValueOrFailure<ClientMetadataHandle>>
 RequestBuffer::Reader::PollPullClientInitialMetadata() {
-  MutexLock lock(&buffer_->mu_);
+  MutexLock lock(buffer_->mu_);
   if (buffer_->winner_ != nullptr && buffer_->winner_ != this) {
     error_ = absl::CancelledError("Another call was chosen");
     return Failure{};

data/src/core/call/request_buffer.h

@@ -108,7 +108,7 @@ class RequestBuffer {
   void Commit(Reader* winner);
 
   bool committed() const {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return winner_ != nullptr;
   }
 

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;