grpc 1.84.0 → 1.85.0.pre1

data/src/core/xds/grpc/xds_transport_grpc.cc

@@ -80,8 +80,10 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::GrpcStreamingCall(
     std::unique_ptr<StreamingCall::EventHandler> event_handler,
     grpc_call_credentials* call_creds,
     const std::vector<std::pair<std::string, std::string>>& initial_metadata,
-    Duration timeout)
-    : factory_(std::move(factory)), event_handler_(std::move(event_handler)) {
+    Duration timeout, CallOptions options)
+    : factory_(std::move(factory)),
+      event_handler_(std::move(event_handler)),
+      options_(options) {
   Timestamp deadline = (timeout == Duration::Infinity())
                            ? Timestamp::InfFuture()
                            : Timestamp::Now() + timeout;
@@ -97,14 +99,6 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::GrpcStreamingCall(
   // Init data associated with the call.
   grpc_metadata_array_init(&initial_metadata_recv_);
   grpc_metadata_array_init(&trailing_metadata_recv_);
-  // Initialize closure to be used for sending messages.
-  GRPC_CLOSURE_INIT(&on_request_sent_, OnRequestSent, this, nullptr);
-  GRPC_CLOSURE_INIT(&on_half_closed_, OnHalfClosed, this, nullptr);
-  // Start ops on the call.
-  grpc_call_error call_error;
-  grpc_op ops[2];
-  memset(ops, 0, sizeof(ops));
-  // Send initial metadata.
   send_initial_metadata_.resize(initial_metadata.size());
   for (size_t i = 0; i < initial_metadata.size(); ++i) {
     send_initial_metadata_[i].key =
@@ -112,46 +106,93 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::GrpcStreamingCall(
     send_initial_metadata_[i].value =
         grpc_slice_from_cpp_string(initial_metadata[i].second);
   }
-  grpc_op* op = ops;
-  op->op = GRPC_OP_SEND_INITIAL_METADATA;
-  op->data.send_initial_metadata.count = send_initial_metadata_.size();
-  op->data.send_initial_metadata.metadata =
-      send_initial_metadata_.empty() ? nullptr : send_initial_metadata_.data();
-  op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY |
-              GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
-  op->reserved = nullptr;
-  ++op;
-  op->op = GRPC_OP_RECV_INITIAL_METADATA;
-  op->data.recv_initial_metadata.recv_initial_metadata =
-      &initial_metadata_recv_;
-  op->flags = 0;
-  op->reserved = nullptr;
-  ++op;
-  // Ref will be released in the callback
-  GRPC_CLOSURE_INIT(
-      &on_recv_initial_metadata_, OnRecvInitialMetadata,
-      this->Ref(DEBUG_LOCATION, "OnRecvInitialMetadata").release(), nullptr);
-  call_error = grpc_call_start_batch_and_execute(
-      call_, ops, static_cast<size_t>(op - ops), &on_recv_initial_metadata_);
-  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
-  // Start a batch for recv_trailing_metadata.
-  memset(ops, 0, sizeof(ops));
-  op = ops;
-  op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
-  op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv_;
-  op->data.recv_status_on_client.status = &status_code_;
-  op->data.recv_status_on_client.status_details = &status_details_;
-  op->flags = 0;
-  op->reserved = nullptr;
-  ++op;
-  // Ref will be released in the callback.
-  GRPC_CLOSURE_INIT(&on_status_received_, OnStatusReceived,
-                    this->Ref(DEBUG_LOCATION, "OnStatusReceived").release(),
+  // Initialize closures.
+  GRPC_CLOSURE_INIT(&on_recv_initial_metadata_, OnRecvInitialMetadata, this,
                     nullptr);
-  call_error = grpc_call_start_batch_and_execute(
-      call_, ops, static_cast<size_t>(op - ops), &on_status_received_);
-  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
+  GRPC_CLOSURE_INIT(&on_request_sent_, OnRequestSent, this, nullptr);
+  GRPC_CLOSURE_INIT(&on_half_closed_, OnHalfClosed, this, nullptr);
   GRPC_CLOSURE_INIT(&on_response_received_, OnResponseReceived, this, nullptr);
+  GRPC_CLOSURE_INIT(&on_status_received_, OnStatusReceived, this, nullptr);
+  // Start batch for recv_initial_metadata (and send_initial_metadata, unless
+  // the caller asked us to wait until the first message is sent).
+  OpList op_list;
+  if (!options_.start_upon_send_message) {
+    sent_initial_metadata_ = true;
+    AddSendInitialMetadataOp(op_list);
+  }
+  AddRecvInitialMetadataOp(op_list);
+  StartBatch(op_list, "OnRecvInitialMetadata", &on_recv_initial_metadata_);
+  // Start batch for recv_trailing_metadata.
+  op_list.clear();
+  AddRecvTrailingMetadataOp(op_list);
+  StartBatch(op_list, "OnStatusReceived", &on_status_received_);
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    AddSendInitialMetadataOp(OpList& op_list) {
+  grpc_op& op = op_list.emplace_back();
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_SEND_INITIAL_METADATA;
+  op.data.send_initial_metadata.count = send_initial_metadata_.size();
+  op.data.send_initial_metadata.metadata =
+      send_initial_metadata_.empty() ? nullptr : send_initial_metadata_.data();
+  op.flags = options_.wait_for_ready
+                 ? GRPC_INITIAL_METADATA_WAIT_FOR_READY |
+                       GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET
+                 : 0;
+  op.reserved = nullptr;
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    AddRecvInitialMetadataOp(OpList& op_list) {
+  grpc_op& op = op_list.emplace_back();
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_RECV_INITIAL_METADATA;
+  op.data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv_;
+  op.flags = 0;
+  op.reserved = nullptr;
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    AddRecvTrailingMetadataOp(OpList& op_list) {
+  grpc_op& op = op_list.emplace_back();
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+  op.data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv_;
+  op.data.recv_status_on_client.status = &status_code_;
+  op.data.recv_status_on_client.status_details = &status_details_;
+  op.flags = 0;
+  op.reserved = nullptr;
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    AddSendCloseFromClientOp(OpList& op_list) {
+  grpc_op& op = op_list.emplace_back();
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
+  op.flags = 0;
+  op.reserved = nullptr;
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
+    AddSendMessageOp(std::string payload, OpList& op_list) {
+  grpc_slice slice = grpc_slice_from_cpp_string(std::move(payload));
+  send_message_payload_ = grpc_raw_byte_buffer_create(&slice, 1);
+  CSliceUnref(slice);
+  grpc_op& op = op_list.emplace_back();
+  memset(&op, 0, sizeof(op));
+  op.op = GRPC_OP_SEND_MESSAGE;
+  op.data.send_message.send_message = send_message_payload_;
+  op.flags = 0;
+  op.reserved = nullptr;
+}
+
+void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::StartBatch(
+    const OpList& op_list, const char* ref_reason, grpc_closure* closure) {
+  Ref(DEBUG_LOCATION, ref_reason).release();
+  grpc_call_error call_error = grpc_call_start_batch_and_execute(
+      call_, op_list.data(), op_list.size(), closure);
+  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
 }
 
 GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
@@ -179,45 +220,36 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::Orphan() {
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::SendMessage(
-    std::string payload) {
-  // Create payload.
-  grpc_slice slice = grpc_slice_from_cpp_string(std::move(payload));
-  send_message_payload_ = grpc_raw_byte_buffer_create(&slice, 1);
-  CSliceUnref(slice);
-  // Send the message.
-  grpc_op op;
-  memset(&op, 0, sizeof(op));
-  op.op = GRPC_OP_SEND_MESSAGE;
-  op.data.send_message.send_message = send_message_payload_;
-  Ref(DEBUG_LOCATION, "OnRequestSent").release();
-  grpc_call_error call_error =
-      grpc_call_start_batch_and_execute(call_, &op, 1, &on_request_sent_);
-  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
+    std::string payload, bool send_half_close) {
+  OpList op_list;
+  if (!sent_initial_metadata_) {
+    sent_initial_metadata_ = true;
+    AddSendInitialMetadataOp(op_list);
+  }
+  AddSendMessageOp(std::move(payload), op_list);
+  if (send_half_close) {
+    AddSendCloseFromClientOp(op_list);
+  }
+  StartBatch(op_list, "OnRequestSent", &on_request_sent_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
     StartRecvMessage() {
-  Ref(DEBUG_LOCATION, "StartRecvMessage").release();
-  grpc_op op;
+  OpList op_list;
+  grpc_op& op = op_list.emplace_back();
   memset(&op, 0, sizeof(op));
   op.op = GRPC_OP_RECV_MESSAGE;
   op.data.recv_message.recv_message = &recv_message_payload_;
-  GRPC_CHECK_NE(call_, nullptr);
-  const grpc_call_error call_error =
-      grpc_call_start_batch_and_execute(call_, &op, 1, &on_response_received_);
-  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
+  op.flags = 0;
+  op.reserved = nullptr;
+  StartBatch(op_list, "StartRecvMessage", &on_response_received_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
     SendHalfClose() {
-  Ref(DEBUG_LOCATION, "SendHalfClose").release();
-  grpc_op op;
-  memset(&op, 0, sizeof(op));
-  op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
-  GRPC_CHECK_NE(call_, nullptr);
-  const grpc_call_error call_error =
-      grpc_call_start_batch_and_execute(call_, &op, 1, &on_half_closed_);
-  GRPC_CHECK_EQ(call_error, GRPC_CALL_OK);
+  OpList op_list;
+  AddSendCloseFromClientOp(op_list);
+  StartBatch(op_list, "SendHalfClose", &on_half_closed_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall::
@@ -303,8 +335,15 @@ RefCountedPtr<Channel> CreateXdsChannel(
   RefCountedPtr<grpc_channel_credentials> channel_creds =
       CoreConfiguration::Get().channel_creds_registry().CreateChannelCreds(
           server.channel_creds_config(), certificate_provider_store);
-  return RefCountedPtr<Channel>(Channel::FromC(grpc_channel_create(
-      server.server_uri().c_str(), channel_creds.get(), args.ToC().get())));
+  ChannelArgs channel_args = args;
+  const grpc_channel_args* child_args =
+      args.GetPointer<grpc_channel_args>(GRPC_ARG_CHILD_CHANNEL_ARGS);
+  if (child_args != nullptr) {
+    channel_args = ChannelArgs::FromC(child_args).UnionWith(args);
+  }
+  return RefCountedPtr<Channel>(Channel::FromC(
+      grpc_channel_create(server.server_uri().c_str(), channel_creds.get(),
+                          channel_args.ToC().get())));
 }
 
 std::string GetChannelKey(const GrpcXdsServerInterface& server) {
@@ -349,7 +388,7 @@ class GrpcXdsTransportFactory::SharedChannel final
         factory_(std::move(factory)) {}
 
   ~SharedChannel() override {
-    MutexLock lock(&factory_->mu_);
+    MutexLock lock(factory_->mu_);
     auto it = factory_->channels_.find(key_);
     if (it != factory_->channels_.end() && it->second == this) {
       factory_->channels_.erase(it);
@@ -393,7 +432,7 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::Orphaned() {
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[GrpcXdsTransport " << this << "] orphaned";
   {
-    MutexLock lock(&factory_->mu_);
+    MutexLock lock(factory_->mu_);
     auto it = factory_->transports_.find(key_);
     if (it != factory_->transports_.end() && it->second == this) {
       factory_->transports_.erase(it);
@@ -414,7 +453,7 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::StartConnectivityFailureWatch(
   if (channel_->channel()->IsLame()) return;
   auto* state_watcher = new StateWatcher(watcher);
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     watchers_.emplace(watcher, state_watcher);
   }
   channel_->channel()->AddConnectivityWatcher(
@@ -427,7 +466,7 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::StopConnectivityFailureWatch(
   if (channel_->channel()->IsLame()) return;
   StateWatcher* state_watcher = nullptr;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto it = watchers_.find(watcher);
     if (it == watchers_.end()) return;
     state_watcher = it->second;
@@ -439,11 +478,12 @@ void GrpcXdsTransportFactory::GrpcXdsTransport::StopConnectivityFailureWatch(
 OrphanablePtr<XdsTransportFactory::XdsTransport::StreamingCall>
 GrpcXdsTransportFactory::GrpcXdsTransport::CreateStreamingCall(
     const char* method,
-    std::unique_ptr<StreamingCall::EventHandler> event_handler) {
+    std::unique_ptr<StreamingCall::EventHandler> event_handler,
+    CallOptions options) {
   return MakeOrphanable<GrpcStreamingCall>(
       factory_.WeakRef(DEBUG_LOCATION, "StreamingCall"), channel_->channel(),
       method, std::move(event_handler), call_creds_.get(), initial_metadata_,
-      timeout_);
+      timeout_, options);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::ResetBackoff() {
@@ -489,7 +529,7 @@ GrpcXdsTransportFactory::GetTransport(
     const XdsBootstrap::XdsServerTarget& server, absl::Status* status) {
   std::string key = server.Key();
   RefCountedPtr<GrpcXdsTransport> transport;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = transports_.find(key);
   if (it != transports_.end()) {
     transport = it->second->RefIfNonZero().TakeAsSubclass<GrpcXdsTransport>();

data/src/core/xds/grpc/xds_transport_grpc.h

@@ -42,6 +42,7 @@
 #include "src/core/xds/xds_client/xds_bootstrap.h"
 #include "src/core/xds/xds_client/xds_transport.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
 
 namespace grpc_core {
@@ -96,7 +97,8 @@ class GrpcXdsTransportFactory::GrpcXdsTransport final
 
   OrphanablePtr<StreamingCall> CreateStreamingCall(
       const char* method,
-      std::unique_ptr<StreamingCall::EventHandler> event_handler) override;
+      std::unique_ptr<StreamingCall::EventHandler> event_handler,
+      CallOptions options) override;
 
   void ResetBackoff() override;
 
@@ -126,18 +128,28 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
       std::unique_ptr<StreamingCall::EventHandler> event_handler,
       grpc_call_credentials* call_creds,
       const std::vector<std::pair<std::string, std::string>>& initial_metadata,
-      Duration timeout);
+      Duration timeout, CallOptions options);
   ~GrpcStreamingCall() override;
 
   void Orphan() override;
 
-  void SendMessage(std::string payload) override;
+  void SendMessage(std::string payload, bool send_half_close) override;
 
   void StartRecvMessage() override;
 
   void SendHalfClose() override;
 
  private:
+  using OpList = absl::InlinedVector<grpc_op, 3>;
+
+  void AddSendInitialMetadataOp(OpList& op_list);
+  void AddRecvInitialMetadataOp(OpList& op_list);
+  void AddRecvTrailingMetadataOp(OpList& op_list);
+  void AddSendCloseFromClientOp(OpList& op_list);
+  void AddSendMessageOp(std::string payload, OpList& op_list);
+  void StartBatch(const OpList& op_list, const char* ref_reason,
+                  grpc_closure* closure);
+
   static void OnRecvInitialMetadata(void* arg, grpc_error_handle /*error*/);
   static void OnRequestSent(void* arg, grpc_error_handle error);
   static void OnHalfClosed(void* arg, grpc_error_handle error);
@@ -157,6 +169,7 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
 
   // send_initial_metadata
   std::vector<grpc_metadata> send_initial_metadata_;
+  bool sent_initial_metadata_ = false;
 
   // send_message
   grpc_byte_buffer* send_message_payload_ = nullptr;
@@ -172,8 +185,10 @@ class GrpcXdsTransportFactory::GrpcXdsTransport::GrpcStreamingCall final
   // recv_trailing_metadata
   grpc_metadata_array trailing_metadata_recv_;
   grpc_status_code status_code_;
-  grpc_slice status_details_;
+  grpc_slice status_details_ = grpc_empty_slice();
   grpc_closure on_status_received_;
+
+  const CallOptions options_;
 };
 
 }  // namespace grpc_core

data/src/core/xds/xds_client/lrs_client.cc

@@ -109,7 +109,7 @@ LrsClient::ClusterDropStats::Snapshot
 LrsClient::ClusterDropStats::GetSnapshotAndReset() {
   Snapshot snapshot;
   snapshot.uncategorized_drops = GetAndResetCounter(&uncategorized_drops_);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   snapshot.categorized_drops = std::move(categorized_drops_);
   return snapshot;
 }
@@ -119,7 +119,7 @@ void LrsClient::ClusterDropStats::AddUncategorizedDrops() {
 }
 
 void LrsClient::ClusterDropStats::AddCallDropped(const std::string& category) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   ++categorized_drops_[category];
 }
 
@@ -178,7 +178,7 @@ LrsClient::ClusterLocalityStats::GetSnapshotAndReset() {
         {},
         {}};
     {
-      MutexLock lock(&percpu_stats.backend_metrics_mu);
+      MutexLock lock(percpu_stats.backend_metrics_mu);
       percpu_snapshot.cpu_utilization = std::move(percpu_stats.cpu_utilization);
       percpu_snapshot.mem_utilization = std::move(percpu_stats.mem_utilization);
       percpu_snapshot.application_utilization =
@@ -204,7 +204,7 @@ void LrsClient::ClusterLocalityStats::AddCallFinished(
   to_increment.fetch_add(1, std::memory_order_relaxed);
   stats.total_requests_in_progress.fetch_add(-1, std::memory_order_acq_rel);
   if (backend_metrics == nullptr) return;
-  MutexLock lock(&stats.backend_metrics_mu);
+  MutexLock lock(stats.backend_metrics_mu);
   if (!XdsOrcaLrsPropagationChangesEnabled()) {
     for (const auto& [name, value] : backend_metrics->named_metrics) {
       stats.backend_metrics[std::string(name)] += BackendMetric(1, value);
@@ -509,7 +509,7 @@ void LrsClient::LrsChannel::RetryableCall<T>::StartRetryTimerLocked() {
 
 template <typename T>
 void LrsClient::LrsChannel::RetryableCall<T>::OnRetryTimer() {
-  MutexLock lock(&lrs_channel_->lrs_client()->mu_);
+  MutexLock lock(lrs_channel_->lrs_client()->mu_);
   if (timer_handle_.has_value()) {
     timer_handle_.reset();
     if (shutting_down_) return;
@@ -548,7 +548,7 @@ void LrsClient::LrsChannel::LrsCall::Timer::ScheduleNextReportLocked() {
 }
 
 void LrsClient::LrsChannel::LrsCall::Timer::OnNextReportTimer() {
-  MutexLock lock(&lrs_client()->mu_);
+  MutexLock lock(lrs_client()->mu_);
   timer_handle_.reset();
   if (IsCurrentTimerOnCall()) lrs_call_->SendReportLocked();
 }
@@ -569,10 +569,13 @@ LrsClient::LrsChannel::LrsCall::LrsCall(
   const char* method =
       "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats";
   streaming_call_ = lrs_channel()->transport_->CreateStreamingCall(
-      method, std::make_unique<StreamEventHandler>(
-                  // Passing the initial ref here.  This ref will go away when
-                  // the StreamEventHandler is destroyed.
-                  RefCountedPtr<LrsCall>(this)));
+      method,
+      std::make_unique<StreamEventHandler>(
+          // Passing the initial ref here.  This ref will go away when
+          // the StreamEventHandler is destroyed.
+          RefCountedPtr<LrsCall>(this)),
+      XdsTransportFactory::XdsTransport::CallOptions().set_wait_for_ready(
+          true));
   GRPC_CHECK(streaming_call_ != nullptr);
   // Start the call.
   GRPC_TRACE_LOG(xds_client, INFO)
@@ -653,13 +656,13 @@ void LrsClient::LrsChannel::LrsCall::SendMessageLocked(std::string payload) {
 }
 
 void LrsClient::LrsChannel::LrsCall::OnRequestSent() {
-  MutexLock lock(&lrs_client()->mu_);
+  MutexLock lock(lrs_client()->mu_);
   send_message_pending_ = false;
   if (IsCurrentCallOnChannel()) MaybeScheduleNextReportLocked();
 }
 
 void LrsClient::LrsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
-  MutexLock lock(&lrs_client()->mu_);
+  MutexLock lock(lrs_client()->mu_);
   // If we're no longer the current call, ignore the result.
   if (!IsCurrentCallOnChannel()) return;
   // Start recv after any code branch
@@ -727,7 +730,7 @@ void LrsClient::LrsChannel::LrsCall::OnRecvMessage(absl::string_view payload) {
 }
 
 void LrsClient::LrsChannel::LrsCall::OnStatusReceived(absl::Status status) {
-  MutexLock lock(&lrs_client()->mu_);
+  MutexLock lock(lrs_client()->mu_);
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[lrs_client " << lrs_client() << "] lrs server "
       << lrs_channel()->server_->server_uri()
@@ -776,7 +779,7 @@ LrsClient::~LrsClient() {
 void LrsClient::Orphaned() {
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[lrs_client " << this << "] shutting down lrs client";
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // We may still be sending lingering queued load report data, so don't
   // just clear the load reporting map, but we do want to clear the refs
   // we're holding to the LrsChannel objects, to make sure that
@@ -808,7 +811,7 @@ RefCountedPtr<LrsClient::ClusterDropStats> LrsClient::AddClusterDropStats(
       std::pair(std::string(cluster_name), std::string(eds_service_name));
   RefCountedPtr<ClusterDropStats> cluster_drop_stats;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // We jump through some hoops here to make sure that the
     // absl::string_views stored in the ClusterDropStats object point
     // to the strings in the load_report_map_ keys, so that
@@ -846,7 +849,7 @@ void LrsClient::RemoveClusterDropStats(
     absl::string_view lrs_server_key, absl::string_view cluster_name,
     absl::string_view eds_service_name,
     LrsClient::ClusterDropStats* cluster_drop_stats) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto server_it = load_report_map_.find(lrs_server_key);
   if (server_it == load_report_map_.end()) return;
   auto& server = server_it->second;
@@ -873,7 +876,7 @@ LrsClient::AddClusterLocalityStats(
       std::pair(std::string(cluster_name), std::string(eds_service_name));
   RefCountedPtr<ClusterLocalityStats> cluster_locality_stats;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // We jump through some hoops here to make sure that the
     // absl::string_views stored in the ClusterLocalityStats object point
     // to the strings in the load_report_map_ keys, so that
@@ -919,7 +922,7 @@ void LrsClient::RemoveClusterLocalityStats(
     const RefCountedPtr<const BackendMetricPropagation>&
         backend_metric_propagation,
     ClusterLocalityStats* cluster_locality_stats) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto server_it = load_report_map_.find(lrs_server_key);
   if (server_it == load_report_map_.end()) return;
   auto& server = server_it->second;
@@ -944,7 +947,7 @@ void LrsClient::RemoveClusterLocalityStats(
 }
 
 void LrsClient::ResetBackoff() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   for (auto& [_, lrs_channel] : lrs_channel_map_) {
     lrs_channel->ResetBackoff();
   }

data/src/core/xds/xds_client/xds_client.cc

@@ -229,7 +229,7 @@ class XdsClient::XdsChannel::AdsCall final
 
     void OnTimer() {
       {
-        MutexLock lock(&ads_call_->xds_client()->mu_);
+        MutexLock lock(ads_call_->xds_client()->mu_);
         timer_handle_.reset();
         auto& authority_state =
             ads_call_->xds_client()->authority_state_map_[name_.authority];
@@ -561,7 +561,7 @@ void XdsClient::XdsChannel::SetHealthyLocked() {
 }
 
 void XdsClient::XdsChannel::OnConnectivityFailure(absl::Status status) {
-  MutexLock lock(&xds_client_->mu_);
+  MutexLock lock(xds_client_->mu_);
   SetChannelStatusLocked(std::move(status));
 }
 
@@ -678,7 +678,7 @@ void XdsClient::XdsChannel::RetryableCall<T>::StartRetryTimerLocked() {
 
 template <typename T>
 void XdsClient::XdsChannel::RetryableCall<T>::OnRetryTimer() {
-  MutexLock lock(&xds_channel_->xds_client()->mu_);
+  MutexLock lock(xds_channel_->xds_client()->mu_);
   if (timer_handle_.has_value()) {
     timer_handle_.reset();
     if (shutting_down_) return;
@@ -701,7 +701,7 @@ class XdsClient::XdsChannel::AdsCall::AdsReadDelayHandle final
       : ads_call_(std::move(ads_call)) {}
 
   ~AdsReadDelayHandle() override {
-    MutexLock lock(&ads_call_->xds_client()->mu_);
+    MutexLock lock(ads_call_->xds_client()->mu_);
     auto call = ads_call_->streaming_call_.get();
     if (call != nullptr) call->StartRecvMessage();
   }
@@ -725,10 +725,13 @@ XdsClient::XdsChannel::AdsCall::AdsCall(
       "/envoy.service.discovery.v3.AggregatedDiscoveryService/"
       "StreamAggregatedResources";
   streaming_call_ = xds_channel()->transport_->CreateStreamingCall(
-      method, std::make_unique<StreamEventHandler>(
-                  // Passing the initial ref here.  This ref will go away when
-                  // the StreamEventHandler is destroyed.
-                  RefCountedPtr<AdsCall>(this)));
+      method,
+      std::make_unique<StreamEventHandler>(
+          // Passing the initial ref here.  This ref will go away when
+          // the StreamEventHandler is destroyed.
+          RefCountedPtr<AdsCall>(this)),
+      XdsTransportFactory::XdsTransport::CallOptions().set_wait_for_ready(
+          true));
   GRPC_CHECK(streaming_call_ != nullptr);
   // Start the call.
   GRPC_TRACE_LOG(xds_client, INFO)
@@ -926,7 +929,7 @@ void XdsClient::XdsChannel::AdsCall::SendMessageLocked(
 }
 
 void XdsClient::XdsChannel::AdsCall::OnRequestSent(bool ok) {
-  MutexLock lock(&xds_client()->mu_);
+  MutexLock lock(xds_client()->mu_);
   // For each resource that was in the message we just sent, start the
   // resource timer if needed.
   if (ok) {
@@ -1309,7 +1312,7 @@ void XdsClient::XdsChannel::AdsCall::OnRecvMessage(absl::string_view payload) {
   // context.read_delay_handle needs to be destroyed after the mutex is
   // released.
   DecodeContext context;
-  MutexLock lock(&xds_client()->mu_);
+  MutexLock lock(xds_client()->mu_);
   if (!IsCurrentCallOnChannel()) return;
   // Parse and validate the response.
   absl::Status status = DecodeAdsResponse(payload, &context);
@@ -1390,7 +1393,7 @@ void XdsClient::XdsChannel::AdsCall::OnRecvMessage(absl::string_view payload) {
 }
 
 void XdsClient::XdsChannel::AdsCall::OnStatusReceived(absl::Status status) {
-  MutexLock lock(&xds_client()->mu_);
+  MutexLock lock(xds_client()->mu_);
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[xds_client " << xds_client() << "] xds server "
       << xds_channel()->server_uri()
@@ -1625,7 +1628,7 @@ XdsClient::~XdsClient() {
 void XdsClient::Orphaned() {
   GRPC_TRACE_LOG(xds_client, INFO)
       << "[xds_client " << this << "] shutting down xds client";
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   shutting_down_ = true;
   // Clear cache and any remaining watchers that may not have been cancelled.
   // Note: We move authority_state_map_ out of the way before clearing
@@ -1670,7 +1673,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
   // Lambda for handling failure cases.
   auto fail = [&](absl::Status status) mutable {
     {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       MaybeRegisterResourceTypeLocked(type);
       invalid_watchers_.insert(watcher);
     }
@@ -1697,7 +1700,7 @@ void XdsClient::WatchResource(const XdsResourceType* type,
     xds_servers = authority->servers();
   }
   if (xds_servers.empty()) xds_servers = bootstrap_->servers();
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   MaybeRegisterResourceTypeLocked(type);
   AuthorityState& authority_state =
       authority_state_map_[resource_name->authority];
@@ -1765,7 +1768,7 @@ void XdsClient::CancelResourceWatch(const XdsResourceType* type,
                                     ResourceWatcherInterface* watcher,
                                     bool delay_unsubscription) {
   auto resource_name = ParseXdsResourceName(name, type);
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   // We cannot be sure whether the watcher is in invalid_watchers_ or in
   // authority_state_map_, so we check both, just to be safe.
   invalid_watchers_.erase(watcher);
@@ -1898,7 +1901,7 @@ std::string XdsClient::ConstructFullXdsResourceName(
 }
 
 void XdsClient::ResetBackoff() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   for (auto& [_, xds_channel] : xds_channel_map_) {
     xds_channel->ResetBackoff();
   }