grpc 1.84.0 → 1.85.0.pre1

data/src/core/lib/promise/inter_activity_latch.h

@@ -42,7 +42,7 @@ class InterActivityLatch {
   // Produce a promise to wait for this latch.
   auto Wait() {
     return [this]() -> Poll<T> {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       GRPC_TRACE_LOG(promise_primitives, INFO)
           << DebugTag() << "PollWait " << StateString();
       if (value_.has_value()) {
@@ -56,7 +56,7 @@ class InterActivityLatch {
 
   // Set the latch.
   void Set(T value) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugTag() << "Set " << StateString();
     value_ = std::move(value);
@@ -64,7 +64,7 @@ class InterActivityLatch {
   }
 
   bool IsSet() const ABSL_LOCKS_EXCLUDED(mu_) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return value_.has_value();
   }
 
@@ -95,7 +95,7 @@ class InterActivityLatch<void> {
   // Produce a promise to wait for this latch.
   auto Wait() {
     return [this]() -> Poll<Empty> {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       GRPC_TRACE_LOG(promise_primitives, INFO)
           << DebugTag() << "PollWait " << StateString();
       if (is_set_) {
@@ -109,7 +109,7 @@ class InterActivityLatch<void> {
 
   // Set the latch.
   void Set() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugTag() << "Set " << StateString();
     is_set_ = true;
@@ -117,7 +117,7 @@ class InterActivityLatch<void> {
   }
 
   bool IsSet() const ABSL_LOCKS_EXCLUDED(mu_) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return is_set_;
   }
 

data/src/core/lib/promise/inter_activity_pipe.h

@@ -110,7 +110,7 @@ class InterActivityPipe {
     }
 
     bool IsClosed() {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       return closed_;
     }
 

data/src/core/lib/promise/observable.h

@@ -65,7 +65,7 @@ class Observable {
 
     // Update the value and wake all observers.
     void Set(T value) {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       std::swap(value_, value);
       WakeAll();
     }
@@ -115,7 +115,7 @@ class Observable {
       // If we saw a pending at all then we *may* be in the set of observers.
       // If not we're definitely not and we can avoid taking the lock at all.
       if (!saw_pending_) return;
-      MutexLock lock(state_->mu());
+      MutexLock lock(*state_->mu());
       auto w = std::move(waker_);
       state_->Remove(this);
     }
@@ -134,7 +134,7 @@ class Observable {
     virtual bool ShouldReturn(const T& current) = 0;
 
     Poll<T> operator()() {
-      MutexLock lock(state_->mu());
+      MutexLock lock(*state_->mu());
       // Check if the value has changed yet.
       if (ShouldReturn(state_->current())) {
         if (saw_pending_ && !waker_.is_unwakeable()) state_->Remove(this);

data/src/core/lib/promise/party.cc

@@ -115,7 +115,7 @@ class Party::Handle final : public Wakeable {
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return party_ == nullptr ? "<unknown>" : party_->DebugTag();
   }
 

data/src/core/lib/promise/try_seq.h

@@ -157,7 +157,7 @@ struct TakeValueExists<T,
 // should terminate the sequence and return.
 template <typename T>
 struct TrySeqTraitsWithSfinae<
-    T, absl::enable_if_t<
+    T, std::enable_if_t<
            std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
                !TakeValueExists<T>::value && AllowGenericTrySeqTraits<T>::value,
            void>> {
@@ -188,7 +188,7 @@ struct TrySeqTraitsWithSfinae<
 };
 template <typename T>
 struct TrySeqTraitsWithSfinae<
-    T, absl::enable_if_t<
+    T, std::enable_if_t<
            std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
                TakeValueExists<T>::value && AllowGenericTrySeqTraits<T>::value,
            void>> {

data/src/core/lib/resource_quota/arena.h

@@ -206,9 +206,9 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   }
 
   template <typename T, typename... Args>
-  absl::enable_if_t<std::is_same<typename T::RefCountedUnrefBehaviorType,
-                                 UnrefCallDtor>::value,
-                    RefCountedPtr<T>>
+  std::enable_if_t<std::is_same<typename T::RefCountedUnrefBehaviorType,
+                                UnrefCallDtor>::value,
+                   RefCountedPtr<T>>
   MakeRefCounted(Args&&... args) {
     return RefCountedPtr<T>(New<T>(std::forward<Args>(args)...));
   }

data/src/core/lib/resource_quota/memory_quota.cc

@@ -64,7 +64,7 @@ class MemoryQuotaTracker {
   }
 
   void Add(std::shared_ptr<BasicMemoryQuota> quota) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // Common usage is that we only create a few (one or two) quotas.
     // We'd like to ensure that we don't OOM if more are added - and
     // using a weak_ptr here, whilst nicely braindead, does run that
@@ -77,7 +77,7 @@ class MemoryQuotaTracker {
   }
 
   std::vector<std::shared_ptr<BasicMemoryQuota>> All() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return GatherAndGarbageCollect();
   }
 
@@ -221,7 +221,7 @@ void ReclaimerQueue::Handle::Sweep::MarkCancelled() {
   // This ensures that we don't suffer from head of line blocking whereby a
   // non-cancelled reclaimer at the head of the queue, in the absence of memory
   // pressure, prevents the remainder of the queue from being cleaned up.
-  MutexLock lock(&state_->reader_mu);
+  MutexLock lock(state_->reader_mu);
   while (true) {
     bool empty = false;
     std::unique_ptr<QueuedNode> node(
@@ -241,13 +241,13 @@ ReclaimerQueue::~ReclaimerQueue() = default;
 
 void ReclaimerQueue::Enqueue(RefCountedPtr<Handle> handle) {
   if (state_->queue.Push(new QueuedNode(std::move(handle)))) {
-    MutexLock lock(&state_->reader_mu);
+    MutexLock lock(state_->reader_mu);
     state_->waker.Wakeup();
   }
 }
 
 Poll<RefCountedPtr<ReclaimerQueue::Handle>> ReclaimerQueue::PollNext() {
-  MutexLock lock(&state_->reader_mu);
+  MutexLock lock(state_->reader_mu);
   bool empty = false;
   // Try to pull from the queue.
   std::unique_ptr<QueuedNode> node(
@@ -290,7 +290,7 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
   OrphanablePtr<ReclaimerQueue::Handle>
       reclamation_handles[kNumReclamationPasses];
   {
-    MutexLock lock(&reclaimer_mu_);
+    MutexLock lock(reclaimer_mu_);
     GRPC_CHECK(!shutdown_);
     shutdown_ = true;
     memory_quota = memory_quota_;
@@ -425,7 +425,7 @@ void GrpcMemoryAllocatorImpl::FillChannelzProperties(
   donate_back_.Interrupt([&list](Duration so_far) {
     list.Set("donate_back_period_expired", so_far);
   });
-  MutexLock lock(&reclaimer_mu_);
+  MutexLock lock(reclaimer_mu_);
   list.Set("shutdown", shutdown_);
 }
 
@@ -610,7 +610,7 @@ void BasicMemoryQuota::AddNewAllocator(GrpcMemoryAllocatorImpl* allocator) {
   AllocatorBucket::Shard& shard = small_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&shard.shard_mu);
+    MutexLock l(shard.shard_mu);
     shard.allocators.emplace(allocator);
   }
 }
@@ -622,7 +622,7 @@ void BasicMemoryQuota::RemoveAllocator(GrpcMemoryAllocatorImpl* allocator) {
       small_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&small_shard.shard_mu);
+    MutexLock l(small_shard.shard_mu);
     if (small_shard.allocators.erase(allocator) == 1) {
       return;
     }
@@ -631,7 +631,7 @@ void BasicMemoryQuota::RemoveAllocator(GrpcMemoryAllocatorImpl* allocator) {
   AllocatorBucket::Shard& big_shard = big_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&big_shard.shard_mu);
+    MutexLock l(big_shard.shard_mu);
     big_shard.allocators.erase(allocator);
   }
 }
@@ -667,14 +667,14 @@ void BasicMemoryQuota::MaybeMoveAllocatorBigToSmall(
   AllocatorBucket::Shard& old_shard = big_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&old_shard.shard_mu);
+    MutexLock l(old_shard.shard_mu);
     if (old_shard.allocators.erase(allocator) == 0) return;
   }
 
   AllocatorBucket::Shard& new_shard = small_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&new_shard.shard_mu);
+    MutexLock l(new_shard.shard_mu);
     new_shard.allocators.emplace(allocator);
   }
 }
@@ -687,14 +687,14 @@ void BasicMemoryQuota::MaybeMoveAllocatorSmallToBig(
   AllocatorBucket::Shard& old_shard = small_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&old_shard.shard_mu);
+    MutexLock l(old_shard.shard_mu);
     if (old_shard.allocators.erase(allocator) == 0) return;
   }
 
   AllocatorBucket::Shard& new_shard = big_allocators_.SelectShard(allocator);
 
   {
-    MutexLock l(&new_shard.shard_mu);
+    MutexLock l(new_shard.shard_mu);
     new_shard.allocators.emplace(allocator);
   }
 }
@@ -735,7 +735,7 @@ void BasicMemoryQuota::AddData(channelz::DataSink sink) {
                [this]() {
                  channelz::PropertyTable table;
                  for (auto& shard : small_allocators_.shards) {
-                   MutexLock l(&shard.shard_mu);
+                   MutexLock l(shard.shard_mu);
                    size_t i = 0;
                    for (auto& allocator : shard.allocators) {
                      i++;
@@ -746,7 +746,7 @@ void BasicMemoryQuota::AddData(channelz::DataSink sink) {
                    }
                  }
                  for (auto& shard : big_allocators_.shards) {
-                   MutexLock l(&shard.shard_mu);
+                   MutexLock l(shard.shard_mu);
                    size_t i = 0;
                    for (auto& allocator : shard.allocators) {
                      i++;

data/src/core/lib/resource_quota/memory_quota.h

@@ -458,7 +458,7 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   // Post a reclamation function.
   template <typename F>
   void PostReclaimer(ReclamationPass pass, F fn) {
-    MutexLock lock(&reclaimer_mu_);
+    MutexLock lock(reclaimer_mu_);
     GRPC_CHECK(!shutdown_);
     InsertReclaimer(static_cast<size_t>(pass), std::move(fn));
   }

data/src/core/lib/resource_quota/thread_quota.cc

@@ -25,19 +25,19 @@ ThreadQuota::ThreadQuota() = default;
 ThreadQuota::~ThreadQuota() = default;
 
 void ThreadQuota::SetMax(size_t new_max) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   max_ = new_max;
 }
 
 bool ThreadQuota::Reserve(size_t num_threads) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (allocated_ + num_threads > max_) return false;
   allocated_ += num_threads;
   return true;
 }
 
 void ThreadQuota::Release(size_t num_threads) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_CHECK(num_threads <= allocated_);
   allocated_ -= num_threads;
 }

data/src/core/lib/security/authorization/audit_logging.cc

@@ -50,21 +50,21 @@ AuditLoggerRegistry::AuditLoggerRegistry() {
 void AuditLoggerRegistry::RegisterFactory(
     std::unique_ptr<AuditLoggerFactory> factory) {
   GRPC_CHECK(factory != nullptr);
-  MutexLock lock(mu);
+  MutexLock lock(*mu);
   absl::string_view name = factory->name();
   GRPC_CHECK(
       registry->logger_factories_map_.emplace(name, std::move(factory)).second);
 }
 
 bool AuditLoggerRegistry::FactoryExists(absl::string_view name) {
-  MutexLock lock(mu);
+  MutexLock lock(*mu);
   return registry->logger_factories_map_.find(name) !=
          registry->logger_factories_map_.end();
 }
 
 absl::StatusOr<std::shared_ptr<const AuditLoggerFactory::Config>>
 AuditLoggerRegistry::ParseConfig(absl::string_view name, const Json& json) {
-  MutexLock lock(mu);
+  MutexLock lock(*mu);
   auto it = registry->logger_factories_map_.find(name);
   if (it == registry->logger_factories_map_.end()) {
     return absl::NotFoundError(
@@ -75,14 +75,14 @@ AuditLoggerRegistry::ParseConfig(absl::string_view name, const Json& json) {
 
 std::unique_ptr<AuditLogger> AuditLoggerRegistry::CreateAuditLogger(
     std::shared_ptr<const AuditLoggerFactory::Config> config) {
-  MutexLock lock(mu);
+  MutexLock lock(*mu);
   auto it = registry->logger_factories_map_.find(config->name());
   GRPC_CHECK(it != registry->logger_factories_map_.end());
   return it->second->CreateAuditLogger(std::move(config));
 }
 
 void AuditLoggerRegistry::TestOnlyResetRegistry() {
-  MutexLock lock(mu);
+  MutexLock lock(*mu);
   delete registry;
   registry = new AuditLoggerRegistry();
 }

data/src/core/lib/security/authorization/authorization_engine.h

@@ -19,7 +19,7 @@
 
 #include <string>
 
-#include "src/core/lib/security/authorization/evaluate_args.h"
+#include "src/core/call/evaluate_args.h"
 #include "src/core/util/ref_counted.h"
 
 namespace grpc_core {

data/src/core/lib/security/authorization/grpc_authorization_engine.h

@@ -23,8 +23,8 @@
 #include <string>
 #include <vector>
 
+#include "src/core/call/evaluate_args.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
-#include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/security/authorization/matchers.h"
 #include "src/core/lib/security/authorization/rbac_policy.h"
 

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -21,13 +21,13 @@
 #include <string>
 #include <utility>
 
+#include "src/core/call/evaluate_args.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/authorization/authorization_engine.h"
-#include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/latent_see.h"
 #include "absl/log/log.h"

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -18,12 +18,12 @@
 #include <grpc/grpc_security.h>
 #include <grpc/support/port_platform.h>
 
+#include "src/core/call/evaluate_args.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/security/authorization/authorization_policy_provider.h"
-#include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/transport/auth_context.h"
 #include "src/core/util/ref_counted_ptr.h"

data/src/core/lib/security/authorization/matchers.h

@@ -23,8 +23,8 @@
 #include <utility>
 #include <vector>
 
+#include "src/core/call/evaluate_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/security/authorization/evaluate_args.h"
 #include "src/core/lib/security/authorization/rbac_policy.h"
 #include "src/core/util/matchers.h"
 

data/src/core/lib/surface/call.cc

@@ -143,11 +143,11 @@ void Call::AddData(channelz::DataSink sink) {
       .Set("encodings_accepted_by_peer",
            encodings_accepted_by_peer_.ToString());
   {
-    MutexLock lock(&peer_mu_);
+    MutexLock lock(peer_mu_);
     properties.Set("peer_string", peer_string_.as_string_view());
   }
   {
-    MutexLock lock(&deadline_mu_);
+    MutexLock lock(deadline_mu_);
     properties.Set("deadline", deadline_);
   }
   sink.AddData("call", properties);
@@ -213,7 +213,7 @@ absl::Status Call::InitParent(Call* parent, uint32_t propagation_mask) {
 void Call::PublishToParent(Call* parent) {
   ChildCall* cc = child_;
   ParentCall* pc = parent->GetOrCreateParentCall();
-  MutexLock lock(&pc->child_list_mu);
+  MutexLock lock(pc->child_list_mu);
   if (pc->first_child == nullptr) {
     pc->first_child = this;
     cc->sibling_next = cc->sibling_prev = this;
@@ -234,7 +234,7 @@ void Call::MaybeUnpublishFromParent() {
 
   ParentCall* pc = cc->parent->parent_call();
   {
-    MutexLock lock(&pc->child_list_mu);
+    MutexLock lock(pc->child_list_mu);
     if (this == pc->first_child) {
       pc->first_child = cc->sibling_next;
       if (this == pc->first_child) {
@@ -260,7 +260,7 @@ void Call::PropagateCancellationToChildren() {
   ParentCall* pc = parent_call();
   if (pc != nullptr) {
     Call* child;
-    MutexLock lock(&pc->child_list_mu);
+    MutexLock lock(pc->child_list_mu);
     child = pc->first_child;
     if (child != nullptr) {
       do {
@@ -356,7 +356,8 @@ void Call::HandleCompressionAlgorithmDisabled(
   std::string error_msg =
       absl::StrFormat("Compression algorithm '%s' is disabled.", algo_name);
   LOG(ERROR) << error_msg;
-  CancelWithError(absl::UnimplementedError(error_msg));
+  CancelWithError(is_client() ? absl::InternalError(error_msg)
+                              : absl::UnimplementedError(error_msg));
 }
 
 grpc_error_handle Call::UpdateDeadline(Timestamp deadline) {
@@ -385,7 +386,7 @@ grpc_error_handle Call::UpdateDeadline(Timestamp deadline) {
 
 void Call::ResetDeadline() {
   {
-    MutexLock lock(&deadline_mu_);
+    MutexLock lock(deadline_mu_);
     if (deadline_ == Timestamp::InfFuture()) return;
     if (!arena_->GetContext<grpc_event_engine::experimental::EventEngine>()
              ->Cancel(deadline_task_)) {

data/src/core/lib/surface/call.h

@@ -127,7 +127,7 @@ class Call : public CppImplOf<Call, grpc_call>,
       ABSL_LOCKS_EXCLUDED(deadline_mu_);
   void ResetDeadline() ABSL_LOCKS_EXCLUDED(deadline_mu_);
   Timestamp deadline() {
-    MutexLock lock(&deadline_mu_);
+    MutexLock lock(deadline_mu_);
     return deadline_;
   }
 
@@ -194,12 +194,12 @@ class Call : public CppImplOf<Call, grpc_call>,
   }
 
   Slice GetPeerString() const {
-    MutexLock lock(&peer_mu_);
+    MutexLock lock(peer_mu_);
     return peer_string_.Ref();
   }
 
   void SetPeerString(Slice peer_string) {
-    MutexLock lock(&peer_mu_);
+    MutexLock lock(peer_mu_);
     peer_string_ = std::move(peer_string);
   }
 

data/src/core/lib/surface/call_utils.h

@@ -106,6 +106,10 @@ class PublishToAppEncoder {
       if constexpr (std::is_same<W3CTraceParentMetadata, Which>::value) {
         Append(Which::key(), value);
       }
+      if constexpr (std::is_same<XEnvoyAuthFailureModeAllowedMetadata,
+                                 Which>::value) {
+        Append(Which::key(), value);
+      }
       if constexpr (std::is_same<XForwardedForMetadata, Which>::value) {
         Append(Which::key(), value);
       }

data/src/core/lib/surface/channel.cc

@@ -74,7 +74,7 @@ Channel::Channel(std::string target, const ChannelArgs& channel_args)
 
 Channel::RegisteredCall* Channel::RegisterCall(const char* method,
                                                const char* host) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto key = std::pair(std::string(host != nullptr ? host : ""),
                        std::string(method != nullptr ? method : ""));
   auto rc_posn = registration_table_.find(key);

data/src/core/lib/surface/channel.h

@@ -113,7 +113,7 @@ class Channel : public UnstartedCallDestination,
   RegisteredCall* RegisterCall(const char* method, const char* host);
 
   int TestOnlyRegisteredCalls() {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return registration_table_.size();
   }
 

data/src/core/lib/surface/channel_init.cc

@@ -519,7 +519,7 @@ void ChannelInit::PrintChannelStackTrace(
   // However, it messes up our logging and makes it harder to reason about the
   // graph, so we add some protection here.
   static Mutex* const m = new Mutex();
-  MutexLock lock(m);
+  MutexLock lock(*m);
   // List the channel stack type (since we'll be repeatedly printing graphs in
   // this loop).
 

data/src/core/lib/surface/init.cc

@@ -111,7 +111,7 @@ static void do_basic_init(void) {
 void grpc_init(void) {
   gpr_once_init(&g_basic_init, do_basic_init);
 
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   if (++g_initializations == 1) {
     if (g_shutting_down) {
       g_shutting_down = false;
@@ -138,7 +138,7 @@ void grpc_shutdown_internal_locked(void)
 
 void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
   GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_from_cleanup_thread";
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   // We have released lock from the shutdown thread and it is possible that
   // another grpc_init has been called, and do nothing if that is the case.
   if (--g_initializations != 0) {
@@ -150,7 +150,7 @@ void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
 
 void grpc_shutdown(void) {
   GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown(void)";
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
 
   if (--g_initializations == 0) {
     if (!grpc_iomgr_is_any_background_poller_thread() &&
@@ -178,7 +178,7 @@ void grpc_shutdown(void) {
 
 void grpc_shutdown_blocking(void) {
   GRPC_TRACE_LOG(api, INFO) << "grpc_shutdown_blocking(void)";
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   if (--g_initializations == 0) {
     g_shutting_down = true;
     grpc_shutdown_internal_locked();
@@ -188,14 +188,14 @@ void grpc_shutdown_blocking(void) {
 int grpc_is_initialized(void) {
   int r;
   gpr_once_init(&g_basic_init, do_basic_init);
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   r = g_initializations > 0;
   return r;
 }
 
 void grpc_maybe_wait_for_async_shutdown(void) {
   gpr_once_init(&g_basic_init, do_basic_init);
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   while (g_shutting_down) {
     g_shutting_down_cv->Wait(g_init_mu);
   }
@@ -206,7 +206,7 @@ bool grpc_wait_for_shutdown_with_timeout(absl::Duration timeout) {
   const auto started = absl::Now();
   const auto deadline = started + timeout;
   gpr_once_init(&g_basic_init, do_basic_init);
-  grpc_core::MutexLock lock(g_init_mu);
+  grpc_core::MutexLock lock(*g_init_mu);
   while (g_initializations != 0) {
     if (g_shutting_down_cv->WaitWithDeadline(g_init_mu, deadline)) {
       GRPC_TRACE_LOG(api, ERROR)

data/src/core/lib/surface/lame_client.cc

@@ -87,7 +87,7 @@ bool LameClientFilter::GetChannelInfo(const grpc_channel_info*) { return true; }
 
 bool LameClientFilter::StartTransportOp(grpc_transport_op* op) {
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (op->start_connectivity_watch != nullptr) {
       state_tracker_.AddWatcher(op->start_connectivity_watch_state,
                                 std::move(op->start_connectivity_watch));

data/src/core/lib/surface/legacy_channel.cc

@@ -269,7 +269,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
 
   void StartTimer(Timestamp deadline) {
     const Duration timeout = deadline - Timestamp::Now();
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     timer_handle_ =
         channel_->event_engine()->RunAfter(timeout, [self = Ref()]() mutable {
           ExecCtx exec_ctx;
@@ -293,7 +293,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
     if (GRPC_TRACE_FLAG_ENABLED(op_failure)) {
       GRPC_LOG_IF_ERROR("watch_completion_error", error);
     }
-    MutexLock lock(&self->mu_);
+    MutexLock lock(self->mu_);
     if (self->timer_handle_.has_value()) {
       self->channel_->event_engine()->Cancel(*self->timer_handle_);
     }

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "56.0.0"; }
+const char* grpc_version_string(void) { return "58.0.0"; }
 
 const char* grpc_g_stands_for(void) { return "gimbal"; }

data/src/core/lib/transport/transport_framing_endpoint_extension.h

@@ -33,10 +33,10 @@ class TransportFramingEndpointExtension {
            "extension";
   }
 
-  // Send data to transport through `cb`. The data will be sent in a single
-  // frame.
+  // Send data to transport through the given callback. The data will be sent in
+  // a single frame.
   virtual void SetSendFrameCallback(
-      absl::AnyInvocable<void(SliceBuffer* data)> cb) = 0;
+      absl::AnyInvocable<void(SliceBuffer data)> cb) = 0;
 
   /// Receive data from transport. The data will be from a single frame.
   virtual void ReceiveFrame(SliceBuffer data) = 0;