grpc 1.84.0.pre1 → 1.85.0.pre1

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);
 }
 

data/src/core/client_channel/subchannel.cc

@@ -580,7 +580,7 @@ class Subchannel::QueuedCall::Canceller final {
     auto* self = static_cast<Canceller*>(arg);
     bool cancelled = false;
     {
-      MutexLock lock(&self->call_->subchannel_->mu_);
+      MutexLock lock(self->call_->subchannel_->mu_);
       if (self->call_->canceller_ == self && !error.ok()) {
         GRPC_TRACE_LOG(subchannel_call, INFO)
             << "subchannel " << self->call_->subchannel_.get()
@@ -592,7 +592,7 @@ class Subchannel::QueuedCall::Canceller final {
       }
     }
     if (cancelled) {
-      MutexLock lock(&self->call_->mu_);
+      MutexLock lock(self->call_->mu_);
       // Fail pending batches on the call.
       self->call_->buffered_call_.Fail(
           error, BufferedCall::YieldCallCombinerIfPendingBatchesFound);
@@ -626,7 +626,7 @@ Subchannel::QueuedCall::~QueuedCall() {
 
 void Subchannel::QueuedCall::SetAfterCallStackDestroy(grpc_closure* closure) {
   GRPC_CHECK_NE(closure, nullptr);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (subchannel_call_ != nullptr) {
     subchannel_call_->SetAfterCallStackDestroy(closure);
   } else {
@@ -641,7 +641,7 @@ void Subchannel::QueuedCall::StartTransportStreamOpBatch(
       << "subchannel " << subchannel_.get() << " queued call " << this
       << ": starting batch: "
       << grpc_transport_stream_op_batch_string(batch, false);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // If we already have a real subchannel call, pass the batch down to it.
   if (subchannel_call_ != nullptr) {
     subchannel_call_->StartTransportStreamOpBatch(batch);
@@ -706,7 +706,7 @@ void Subchannel::QueuedCall::ResumeOnConnectionLocked(
       << ": resuming on connected_subchannel " << connected_subchannel;
   canceller_ = nullptr;
   queue_entry_ = nullptr;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_error_handle error;
   subchannel_call_ = connected_subchannel->CreateCall(args_, &error);
   if (after_call_stack_destroy_ != nullptr) {
@@ -739,7 +739,7 @@ void Subchannel::QueuedCall::FailLocked(absl::Status status) {
   canceller_ = nullptr;
   queue_entry_ = nullptr;
   is_retriable_.store(true);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   cancel_error_ = status;
   buffered_call_.Fail(status,
                       BufferedCall::YieldCallCombinerIfPendingBatchesFound);
@@ -790,7 +790,8 @@ class Subchannel::NewConnectedSubchannel final : public ConnectedSubchannel {
   }
 
   void Ping(absl::AnyInvocable<void(absl::Status)>) override {
-    // TODO(ctiller): add new transport API for this in v3 stack
+    // TODO(akshitpatel) : [PH2][P2][Client] : add new transport API for this in
+    // v3 stack
     Crash("not implemented");
   }
 
@@ -840,7 +841,7 @@ class Subchannel::ConnectionStateWatcher final
                 ? disconnect_info.keepalive_time->ToString()
                 : "<unset>")
         << ")";
-    MutexLock lock(&subchannel->mu_);
+    MutexLock lock(subchannel->mu_);
     // Handle keepalive update.
     if (disconnect_info.keepalive_time.has_value()) {
       subchannel->ThrottleKeepaliveTimeLocked(*disconnect_info.keepalive_time);
@@ -1124,7 +1125,7 @@ RefCountedPtr<Subchannel> Subchannel::Create(
 }
 
 void Subchannel::ThrottleKeepaliveTime(Duration new_keepalive_time) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   ThrottleKeepaliveTimeLocked(new_keepalive_time);
 }
 
@@ -1145,7 +1146,7 @@ channelz::SubchannelNode* Subchannel::channelz_node() {
 
 void Subchannel::WatchConnectivityState(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
   if (interested_parties != nullptr) {
     grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
@@ -1163,7 +1164,7 @@ void Subchannel::WatchConnectivityState(
 
 void Subchannel::CancelConnectivityStateWatch(
     ConnectivityStateWatcherInterface* watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
   if (interested_parties != nullptr) {
     grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
@@ -1175,7 +1176,7 @@ void Subchannel::RequestConnection() {
   GRPC_TRACE_LOG(subchannel, INFO)
       << "subchannel " << this << " " << key_.ToString()
       << ": RequestConnection()";
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (state_ == GRPC_CHANNEL_IDLE) {
     StartConnectingLocked();
   }
@@ -1188,7 +1189,7 @@ void Subchannel::ResetBackoff() {
   // does not eliminate the last ref and destroy the Subchannel before the
   // method returns.
   auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   backoff_.Reset();
   if (retry_timer_handle_.has_value() &&
       event_engine_->Cancel(*retry_timer_handle_)) {
@@ -1207,7 +1208,7 @@ void Subchannel::Orphaned() {
     subchannel_pool_->UnregisterSubchannel(key_, this);
     subchannel_pool_.reset();
   }
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_CHECK(!shutdown_);
   shutdown_ = true;
   connector_.reset();
@@ -1220,13 +1221,13 @@ void Subchannel::Orphaned() {
 void Subchannel::GetOrAddDataProducer(
     UniqueTypeName type,
     std::function<void(DataProducerInterface**)> get_or_add) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = data_producer_map_.emplace(type, nullptr).first;
   get_or_add(&it->second);
 }
 
 void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = data_producer_map_.find(data_producer->type());
   if (it != data_producer_map_.end() && it->second == data_producer) {
     data_producer_map_.erase(it);
@@ -1315,7 +1316,7 @@ bool Subchannel::RemoveConnectionLocked(
 }
 
 void Subchannel::OnRetryTimer() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   OnRetryTimerLocked();
 }
 
@@ -1351,7 +1352,7 @@ void Subchannel::StartConnectingLocked() {
 void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
   WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
   {
-    MutexLock lock(&c->mu_);
+    MutexLock lock(c->mu_);
     c->OnConnectingFinishedLocked(error);
   }
   c.reset(DEBUG_LOCATION, "Connect");
@@ -1513,7 +1514,7 @@ RefCountedPtr<Subchannel::Call> Subchannel::CreateCall(
     CreateCallArgs args, grpc_error_handle* error) {
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // If we hit a race condition where the LB picker chose the subchannel
     // at the same time as the last connection was closed, then tell the
     // channel to re-queue the pick.
@@ -1539,10 +1540,10 @@ RefCountedPtr<Subchannel::Call> Subchannel::CreateCall(
 }
 
 RefCountedPtr<UnstartedCallDestination> Subchannel::call_destination() {
-  // TODO(roth): Implement connection scaling for v3.
+  // TODO(roth) : [PH2][P2][Client] : Implement connection scaling for v3.
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!connections_.empty()) connected_subchannel = connections_[0];
   }
   if (connected_subchannel == nullptr) return nullptr;
@@ -1582,7 +1583,7 @@ Subchannel::ChooseConnectionLocked() {
 }
 
 void Subchannel::RetryQueuedRpcs() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (shutdown_) return;
   RetryQueuedRpcsLocked();
 }
@@ -1644,7 +1645,7 @@ void Subchannel::Ping(absl::AnyInvocable<void(absl::Status)>) {
 absl::Status Subchannel::Ping(grpc_closure* on_initiate, grpc_closure* on_ack) {
   RefCountedPtr<ConnectedSubchannel> connected_subchannel;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!connections_.empty()) connected_subchannel = connections_[0];
   }
   if (connected_subchannel == nullptr) {

data/src/core/client_channel/subchannel_stream_client.cc

@@ -90,7 +90,7 @@ void SubchannelStreamClient::Orphan() {
               << ": SubchannelStreamClient shutting down";
   }
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     event_handler_.reset();
     call_state_.reset();
     if (retry_timer_handle_.has_value()) {
@@ -102,7 +102,7 @@ void SubchannelStreamClient::Orphan() {
 }
 
 void SubchannelStreamClient::StartCall() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   StartCallLocked();
 }
 
@@ -150,7 +150,7 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
 }
 
 void SubchannelStreamClient::OnRetryTimer() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (event_handler_ != nullptr && retry_timer_handle_.has_value() &&
       call_state_ == nullptr) {
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
@@ -353,7 +353,7 @@ void SubchannelStreamClient::CallState::RecvMessageReady() {
   }
   // Report payload.
   {
-    MutexLock lock(&subchannel_stream_client_->mu_);
+    MutexLock lock(subchannel_stream_client_->mu_);
     if (subchannel_stream_client_->event_handler_ != nullptr) {
       absl::Status status =
           subchannel_stream_client_->event_handler_->RecvMessageReadyLocked(
@@ -418,7 +418,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   // that it lives long enough for us to release the mutex, since the
   // call to CallEndedLocked() may release the last ref.
   auto subchannel_stream_client = self->subchannel_stream_client_->Ref();
-  MutexLock lock(&self->subchannel_stream_client_->mu_);
+  MutexLock lock(self->subchannel_stream_client_->mu_);
   if (self->subchannel_stream_client_->event_handler_ != nullptr) {
     self->subchannel_stream_client_->event_handler_
         ->RecvTrailingMetadataReadyLocked(self->subchannel_stream_client_.get(),

data/src/core/credentials/call/external/aws_external_account_credentials.cc

@@ -91,7 +91,7 @@ AwsExternalAccountCredentials::AwsFetchBody::AwsFetchBody(
     absl::AnyInvocable<void(absl::StatusOr<std::string>)> on_done,
     AwsExternalAccountCredentials* creds, Timestamp deadline)
     : FetchBody(std::move(on_done)), creds_(creds), deadline_(deadline) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // Do a quick async hop here, so that we can invoke the callback at
   // any time without deadlocking.
   fetch_body_ = MakeOrphanable<NoOpFetchBody>(
@@ -102,7 +102,7 @@ AwsExternalAccountCredentials::AwsFetchBody::AwsFetchBody(
 }
 
 void AwsExternalAccountCredentials::AwsFetchBody::Shutdown() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   fetch_body_.reset();
 }
 
@@ -131,7 +131,7 @@ bool AwsExternalAccountCredentials::AwsFetchBody::MaybeFail(
 }
 
 void AwsExternalAccountCredentials::AwsFetchBody::Start() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (MaybeFail(absl::OkStatus())) return;
   if (!creds_->imdsv2_session_token_url_.empty() && ShouldUseMetadataServer()) {
     RetrieveImdsV2SessionToken();
@@ -175,7 +175,7 @@ void AwsExternalAccountCredentials::AwsFetchBody::RetrieveImdsV2SessionToken() {
       },
       [self =
            RefAsSubclass<AwsFetchBody>()](absl::StatusOr<std::string> result) {
-        MutexLock lock(&self->mu_);
+        MutexLock lock(self->mu_);
         if (self->MaybeFail(result.status())) return;
         self->imdsv2_session_token_ = std::move(*result);
         if (self->creds_->signer_ != nullptr) {
@@ -228,7 +228,7 @@ void AwsExternalAccountCredentials::AwsFetchBody::RetrieveRegion() {
       },
       [self =
            RefAsSubclass<AwsFetchBody>()](absl::StatusOr<std::string> result) {
-        MutexLock lock(&self->mu_);
+        MutexLock lock(self->mu_);
         if (self->MaybeFail(result.status())) return;
         // Remove the last letter of availability zone to get pure region
         self->region_ = result->substr(0, result->size() - 1);
@@ -270,7 +270,7 @@ void AwsExternalAccountCredentials::AwsFetchBody::RetrieveRoleName() {
       },
       [self =
            RefAsSubclass<AwsFetchBody>()](absl::StatusOr<std::string> result) {
-        MutexLock lock(&self->mu_);
+        MutexLock lock(self->mu_);
         if (self->MaybeFail(result.status())) return;
         self->role_name_ = std::move(*result);
         self->RetrieveSigningKeys();
@@ -326,7 +326,7 @@ void AwsExternalAccountCredentials::AwsFetchBody::RetrieveSigningKeys() {
       },
       [self =
            RefAsSubclass<AwsFetchBody>()](absl::StatusOr<std::string> result) {
-        MutexLock lock(&self->mu_);
+        MutexLock lock(self->mu_);
         if (self->MaybeFail(result.status())) return;
         self->OnRetrieveSigningKeys(std::move(*result));
       });

data/src/core/credentials/call/external/aws_request_signer.cc

@@ -18,12 +18,15 @@
 #include <grpc/support/port_platform.h>
 #include <openssl/crypto.h>
 #include <openssl/evp.h>
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
 #include <openssl/hmac.h>
+#endif
 #include <openssl/sha.h>
 
 #include <utility>
 #include <vector>
 
+#include "src/core/util/grpc_check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
@@ -41,6 +44,7 @@ namespace {
 
 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
 const char kSha256[] = "SHA256";
+const char kHmacName[] = "HMAC";
 #endif
 const char kAlgorithm[] = "AWS4-HMAC-SHA256";
 const char kDateFormat[] = "%a, %d %b %E4Y %H:%M:%S %Z";
@@ -67,12 +71,24 @@ std::string SHA256Hex(const std::string& str) {
 }
 
 std::string HMAC(const std::string& key, const std::string& msg) {
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   unsigned int len;
   unsigned char digest[EVP_MAX_MD_SIZE];
   HMAC(EVP_sha256(), key.c_str(), key.length(),
        reinterpret_cast<const unsigned char*>(msg.c_str()), msg.length(),
        digest, &len);
   return std::string(digest, digest + len);
+#else
+  size_t len = 0;
+  unsigned char digest[EVP_MAX_MD_SIZE];
+  GRPC_CHECK_NE(EVP_Q_mac(nullptr, kHmacName, nullptr, kSha256, nullptr,
+                          reinterpret_cast<const unsigned char*>(key.c_str()),
+                          key.length(),
+                          reinterpret_cast<const unsigned char*>(msg.c_str()),
+                          msg.length(), digest, sizeof(digest), &len),
+                nullptr);
+  return std::string(digest, digest + len);
+#endif
 }
 
 }  // namespace

data/src/core/credentials/call/external/external_account_credentials.cc

@@ -181,7 +181,7 @@ ExternalAccountCredentials::ExternalFetchRequest::ExternalFetchRequest(
 
 void ExternalAccountCredentials::ExternalFetchRequest::Orphan() {
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     fetch_body_.reset();
   }
   Unref();
@@ -211,7 +211,7 @@ std::string UrlEncode(const absl::string_view s) {
 
 void ExternalAccountCredentials::ExternalFetchRequest::ExchangeToken(
     absl::StatusOr<std::string> subject_token) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (MaybeFailLocked(subject_token.status())) return;
   // Parse URI.
   absl::StatusOr<URI> uri = URI::Parse(options().token_url);
@@ -300,7 +300,7 @@ void ExternalAccountCredentials::ExternalFetchRequest::ExchangeToken(
 
 void ExternalAccountCredentials::ExternalFetchRequest::
     MaybeImpersonateServiceAccount(absl::StatusOr<std::string> response_body) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (MaybeFailLocked(response_body.status())) return;
   // If not doing impersonation, response_body contains oauth token.
   if (options().service_account_impersonation_url.empty()) {
@@ -381,7 +381,7 @@ void ExternalAccountCredentials::ExternalFetchRequest::
 
 void ExternalAccountCredentials::ExternalFetchRequest::
     OnImpersonateServiceAccount(absl::StatusOr<std::string> response_body) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (MaybeFailLocked(response_body.status())) return;
   auto json = JsonParse(*response_body);
   if (!json.ok()) {

data/src/core/credentials/call/regional_access_boundary_fetcher.cc

@@ -84,7 +84,7 @@ RegionalAccessBoundaryFetcher::RegionalAccessBoundaryFetcher(
 }
 
 void RegionalAccessBoundaryFetcher::OnFetchSuccess(Slice encoded_locations) {
-  MutexLock lock(&cache_mu_);
+  MutexLock lock(cache_mu_);
   if (shutdown_) return;
   cache_ = {std::move(encoded_locations),
             Timestamp::Now() + kRegionalAccessBoundaryCacheDuration};
@@ -94,7 +94,7 @@ void RegionalAccessBoundaryFetcher::OnFetchSuccess(Slice encoded_locations) {
 
 void RegionalAccessBoundaryFetcher::OnFetchFailure(
     grpc_error_handle error, int http_status, absl::string_view response_body) {
-  MutexLock lock(&cache_mu_);
+  MutexLock lock(cache_mu_);
   if (shutdown_) return;
   auto log_message = absl::StrCat(
       "Regional access boundary request will be retried after failing with "
@@ -134,7 +134,7 @@ void RegionalAccessBoundaryFetcher::Fetch(absl::string_view access_token,
   }
   {
     const Timestamp now = Timestamp::Now();
-    MutexLock lock(&cache_mu_);
+    MutexLock lock(cache_mu_);
     // We kick off a new fetch attempt if all of the following are true:
     // - We have no cached Regioanl Access Boundary data, or the cached
     //   Regional Access Boundary data's expiration time is less than the grace
@@ -161,7 +161,7 @@ void RegionalAccessBoundaryFetcher::Fetch(absl::string_view access_token,
 }
 
 void RegionalAccessBoundaryFetcher::Orphaned() {
-  MutexLock lock(&cache_mu_);
+  MutexLock lock(cache_mu_);
   shutdown_ = true;
   pending_request_.reset();
 }
@@ -323,7 +323,7 @@ EmailFetcher::EmailFetcher(
 EmailFetcher::~EmailFetcher() = default;
 
 void EmailFetcher::StartEmailFetch() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (Timestamp::Now() < next_fetch_earliest_time_) {
     return;
   }
@@ -338,7 +338,7 @@ void EmailFetcher::StartEmailFetch() {
 
 void EmailFetcher::Fetch(absl::string_view token,
                          ClientMetadata& initial_metadata) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto* rab_fetcher =
       std::get_if<RefCountedPtr<RegionalAccessBoundaryFetcher>>(&state_);
   if (rab_fetcher == nullptr) return;   // Don't yet have RAB fetcher.
@@ -347,12 +347,12 @@ void EmailFetcher::Fetch(absl::string_view token,
 }
 
 void EmailFetcher::Orphaned() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   state_ = RefCountedPtr<RegionalAccessBoundaryFetcher>(nullptr);
 }
 
 void EmailFetcher::OnEmailFetchComplete(absl::string_view email) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::holds_alternative<OrphanablePtr<EmailRequest>>(state_)) {
     absl::string_view trimmed_email = absl::StripAsciiWhitespace(email);
     if (!IsValidEmail(trimmed_email)) {
@@ -378,7 +378,7 @@ void EmailFetcher::OnEmailFetchComplete(absl::string_view email) {
 }
 
 void EmailFetcher::OnEmailFetchError(grpc_error_handle error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::holds_alternative<OrphanablePtr<EmailRequest>>(state_)) {
     LOG_EVERY_N_SEC(INFO, 60) << "Regional Access Boundary fetch skipped due "
                                  "to service account email fetch failure: "