grpc 1.84.1 → 1.85.0.pre1

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

@@ -0,0 +1,181 @@
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "src/core/xds/grpc/streaming_call_promise_wrapper.h"
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// EventHandler bridges callback-driven events from XdsTransport::StreamingCall
+// into XdsStreamingCallPromiseWrapper. It holds a weak reference to avoid
+// reference cycles between the transport stream and the wrapper.
+class XdsStreamingCallPromiseWrapper::EventHandler final
+    : public XdsTransportFactory::XdsTransport::StreamingCall::EventHandler {
+ public:
+  explicit EventHandler(
+      WeakRefCountedPtr<XdsStreamingCallPromiseWrapper> promise_wrapper)
+      : promise_wrapper_(std::move(promise_wrapper)) {}
+
+  void OnRequestSent(bool ok) override { promise_wrapper_->OnRequestSent(ok); }
+
+  void OnRecvMessage(absl::string_view payload) override {
+    promise_wrapper_->OnRecvMessage(payload);
+  }
+
+  void OnStatusReceived(absl::Status status) override {
+    promise_wrapper_->OnStatusReceived(std::move(status));
+  }
+
+ private:
+  WeakRefCountedPtr<XdsStreamingCallPromiseWrapper> promise_wrapper_;
+};
+
+XdsStreamingCallPromiseWrapper::XdsStreamingCallPromiseWrapper(
+    XdsTransport& transport, const char* method,
+    XdsTransport::CallOptions options) {
+  auto internal_event_handler = std::make_unique<EventHandler>(
+      WeakRefAsSubclass<XdsStreamingCallPromiseWrapper>());
+  call_ = transport.CreateStreamingCall(
+      method, std::move(internal_event_handler), options);
+}
+
+Poll<StatusFlag> XdsStreamingCallPromiseWrapper::PollPushMessage() {
+  MutexLock lock(mu_);
+  // If the send is still in flight on the transport, wait for completion.
+  if (send_state_ == SendState::kSendMessageInFlight ||
+      send_state_ == SendState::kSendMessageAndHalfCloseInFlight ||
+      send_state_ == SendState::kSendMessageInFlightAndHalfCloseRequested) {
+    return Pending{};
+  }
+  // If the send failed or the stream terminated while the send was pending,
+  // resolve to failure.
+  if (send_state_ == SendState::kSendFailed) {
+    return Failure{};
+  }
+  return Success{};
+}
+
+Poll<std::optional<std::string>>
+XdsStreamingCallPromiseWrapper::PollPullMessage() {
+  MutexLock lock(mu_);
+  switch (recv_state_) {
+    case RecvState::kIdle:
+      return std::exchange(recv_message_, std::nullopt);
+    case RecvState::kRecvMessageInFlight:
+      return Pending{};
+    case RecvState::kReceivedStatus:
+      return std::nullopt;
+    default:
+      return Pending{};
+  }
+}
+
+Poll<absl::Status>
+XdsStreamingCallPromiseWrapper::PollPullServerTrailingMetadata() {
+  MutexLock lock(mu_);
+  if (recv_state_ != RecvState::kReceivedStatus) return Pending{};
+  return std::move(status_);
+}
+
+void XdsStreamingCallPromiseWrapper::OnRequestSent(bool ok) {
+  Waker waker;
+  bool send_half_close = false;
+  {
+    MutexLock lock(mu_);
+    if (!ok) {
+      send_state_ = SendState::kSendFailed;
+    } else {
+      if (send_state_ == SendState::kSendMessageInFlightAndHalfCloseRequested) {
+        send_state_ = SendState::kHalfCloseInFlight;
+        send_half_close = true;
+      } else if (send_state_ == SendState::kSendMessageAndHalfCloseInFlight) {
+        send_state_ = SendState::kHalfCloseInFlight;
+      } else if (send_state_ == SendState::kSendMessageInFlight) {
+        send_state_ = SendState::kIdle;
+      }
+    }
+    waker = std::move(send_message_waker_);
+  }
+  if (send_half_close) {
+    call_->SendHalfClose();
+  }
+  // Wake any waiting send promise.
+  waker.Wakeup();
+}
+
+void XdsStreamingCallPromiseWrapper::OnRecvMessage(absl::string_view payload) {
+  Waker waker;
+  {
+    MutexLock lock(mu_);
+    recv_message_ = std::string(payload);
+    if (recv_state_ == RecvState::kRecvMessageInFlight) {
+      recv_state_ = RecvState::kIdle;
+    }
+    waker = std::move(recv_message_waker_);
+  }
+  waker.Wakeup();
+}
+
+void XdsStreamingCallPromiseWrapper::OnStatusReceived(absl::Status status) {
+  Waker recv_message_waker;
+  Waker recv_status_waker;
+  {
+    MutexLock lock(mu_);
+    status_ = std::move(status);
+    if (recv_state_ == RecvState::kRecvMessageInFlight) {
+      recv_message_waker = std::move(recv_message_waker_);
+    }
+    recv_state_ = RecvState::kReceivedStatus;
+    recv_status_waker = std::move(recv_status_waker_);
+  }
+  recv_message_waker.Wakeup();
+  recv_status_waker.Wakeup();
+}
+
+void XdsStreamingCallPromiseWrapper::SendHalfClose() {
+  bool send_half_close = false;
+  {
+    MutexLock lock(mu_);
+    // If a send is in flight, record that half-close was requested.
+    // OnRequestSent will issue the half-close once the message send completes.
+    if (send_state_ == SendState::kSendMessageInFlight) {
+      send_state_ = SendState::kSendMessageInFlightAndHalfCloseRequested;
+    } else if (send_state_ == SendState::kIdle) {
+      send_state_ = SendState::kHalfCloseInFlight;
+      send_half_close = true;
+    }
+  }
+  if (send_half_close) {
+    call_->SendHalfClose();
+  }
+}
+
+void XdsStreamingCallPromiseWrapper::Orphaned() {
+  // Release the underlying streaming call.
+  call_.reset();
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,213 @@
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_XDS_GRPC_STREAMING_CALL_PROMISE_WRAPPER_H
+#define GRPC_SRC_CORE_XDS_GRPC_STREAMING_CALL_PROMISE_WRAPPER_H
+
+#include <optional>
+#include <string>
+
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/sync.h"
+#include "src/core/xds/xds_client/xds_transport.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// A promise-based wrapper around
+// XdsTransportFactory::XdsTransport::StreamingCall.
+//
+// This class adapts callback-based xDS streaming transport calls into gRPC
+// Core's promise-based architecture. It provides asynchronous promise
+// primitives for sending requests, pulling incoming server messages, and
+// waiting for server trailing metadata.
+//
+// DualRefCounted is used to manage object lifetime: strong references are held
+// by clients and active promise workflows, while weak references are passed to
+// the underlying transport event handler to avoid reference cycles.
+class XdsStreamingCallPromiseWrapper final
+    : public DualRefCounted<XdsStreamingCallPromiseWrapper> {
+ public:
+  using XdsTransport = XdsTransportFactory::XdsTransport;
+
+  // Constructs a new streaming call wrapper for the given method on the
+  // transport.
+  XdsStreamingCallPromiseWrapper(
+      XdsTransport& transport, const char* method,
+      XdsTransport::CallOptions options = XdsTransport::CallOptions());
+
+  // Pushes a message on the stream.
+  //
+  // Returns a promise that resolves to StatusFlag, indicating whether the
+  // message was sent successfully.
+  //
+  // Contract: The caller MUST NOT call PushMessage() again until the promise
+  // from the previous PushMessage() resolves. If send_half_close is true, no
+  // further messages can be pushed on the stream.
+  auto PushMessage(std::string msg, bool send_half_close = false) {
+    {
+      MutexLock lock(mu_);
+      GRPC_CHECK(send_state_ == SendState::kIdle);
+      send_state_ = send_half_close
+                        ? SendState::kSendMessageAndHalfCloseInFlight
+                        : SendState::kSendMessageInFlight;
+      send_message_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+    }
+    call_->SendMessage(std::move(msg), send_half_close);
+    return [self = WeakRefAsSubclass<XdsStreamingCallPromiseWrapper>()]() {
+      return self->PollPushMessage();
+    };
+  }
+
+  // Pulls an incoming message from the stream.
+  //
+  // Returns a promise that resolves to std::optional<std::string>.
+  // The value will be nullopt when the stream is closed without
+  // receiving a message.
+  auto PullMessage() {
+    bool start_recv = false;
+    {
+      MutexLock lock(mu_);
+      if (recv_state_ == RecvState::kIdle) {
+        recv_state_ = RecvState::kRecvMessageInFlight;
+        recv_message_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+        start_recv = true;
+      } else {
+        // Must be kReceivedStatus. Don't actually need to start the
+        // recv_message op; we'll return nullopt on the first poll.
+        GRPC_CHECK(recv_state_ == RecvState::kReceivedStatus);
+      }
+    }
+    if (start_recv) {
+      call_->StartRecvMessage();
+    }
+    return [self = WeakRefAsSubclass<XdsStreamingCallPromiseWrapper>()]() {
+      return self->PollPullMessage();
+    };
+  }
+
+  // Waits for server trailing metadata and stream termination.
+  //
+  // Returns a promise that resolves to absl::Status, indicating
+  // the final status of the call.
+  auto PullServerTrailingMetadata() {
+    {
+      MutexLock lock(mu_);
+      if (recv_state_ != RecvState::kReceivedStatus) {
+        recv_status_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+      }
+    }
+    return [self = WeakRefAsSubclass<XdsStreamingCallPromiseWrapper>()]() {
+      return self->PollPullServerTrailingMetadata();
+    };
+  }
+
+  // Requests a half-close (client EOF) on the stream, indicating that no
+  // further messages will be sent by the client.
+  void SendHalfClose();
+
+ private:
+  class EventHandler;
+
+  // Called when all strong references are dropped.
+  // Cancels the underlying stream and wakes any pending promises with a
+  // cancellation status.
+  void Orphaned() override;
+
+  enum class SendState {
+    // Initial state: no send op in flight.
+    // Upon calling PushMessage(), transitions to kSendMessageInFlight or
+    // kSendMessageAndHalfCloseInFlight.
+    // Upon calling SendHalfClose(), transitions to kHalfCloseInFlight.
+    kIdle,
+    // Send message in flight.
+    // If the send fails, transitions to kSendFailed.
+    // Otherwise, if SendHalfClose() was called before the send completed,
+    // transitions to kSendMessageInFlightAndHalfCloseRequested.
+    // Otherwise, transitions to kIdle.
+    kSendMessageInFlight,
+    // Send message and half close in flight.
+    // If the send fails, transitions to kSendFailed.
+    // Otherwise, transitions to kHalfCloseInFlight.
+    kSendMessageAndHalfCloseInFlight,
+    // A send failed.
+    // Once entering this state, we never leave.
+    kSendFailed,
+    // A send message is in flight, and a half close has been requested.
+    // If the send fails, transitions to kSendFailed.
+    // Otherwise, transitions to kHalfCloseInFlight.
+    kSendMessageInFlightAndHalfCloseRequested,
+    // A half-close is in flight or has completed.
+    kHalfCloseInFlight,
+  };
+
+  enum class RecvState {
+    // Initial state.
+    // If status is received, transitions to kReceivedStatus.
+    // If PullMessage() is called, transitions to kRecvMessageInFlight.
+    kIdle,
+    // A PullMessage() promise is pending.
+    // If a message is received, transitions to kIdle.
+    // If status is received, transitions to kReceivedStatus.
+    kRecvMessageInFlight,
+    // Status has been received.
+    // We never leave this state.
+    kReceivedStatus,
+  };
+
+  // Internal polling implementation for PushMessage().
+  Poll<StatusFlag> PollPushMessage();
+
+  // Internal polling implementation for PullMessage().
+  Poll<std::optional<std::string>> PollPullMessage();
+
+  // Internal polling implementation for PullServerTrailingMetadata().
+  Poll<absl::Status> PollPullServerTrailingMetadata();
+
+  // Transport callback handlers invoked by EventHandler on the transport
+  // thread.
+  void OnRequestSent(bool ok);
+  void OnRecvMessage(absl::string_view payload);
+  void OnStatusReceived(absl::Status status);
+
+  Mutex mu_;
+
+  OrphanablePtr<XdsTransportFactory::XdsTransport::StreamingCall> call_;
+
+  // State for outgoing messages (PushMessage).
+  SendState send_state_ ABSL_GUARDED_BY(mu_) = SendState::kIdle;
+  Waker send_message_waker_ ABSL_GUARDED_BY(mu_);
+
+  // State for incoming messages (PullMessage).
+  RecvState recv_state_ ABSL_GUARDED_BY(mu_) = RecvState::kIdle;
+  Waker recv_message_waker_ ABSL_GUARDED_BY(mu_);
+  std::optional<std::string> recv_message_ ABSL_GUARDED_BY(mu_);
+
+  // Trailing metadata status from the server (PullServerTrailingMetadata).
+  Waker recv_status_waker_ ABSL_GUARDED_BY(mu_);
+  absl::Status status_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_XDS_GRPC_STREAMING_CALL_PROMISE_WRAPPER_H

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

@@ -79,7 +79,7 @@ NoDestruct<absl::AnyInvocable<void(XdsHttpFilterRegistry&)>>
 
 void GrpcXdsBootstrapBuilder::SetXdsHttpFilterFactoryInitForTest(
     absl::AnyInvocable<void(XdsHttpFilterRegistry&)> init) {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   *g_http_filter_factory_test_init = std::move(init);
 }
 
@@ -100,7 +100,7 @@ XdsHttpFilterRegistry GrpcXdsBootstrapBuilder::CreateXdsHttpFilterRegistry(
     if (IsExperimentEnvVarEnabled("GRPC_EXPERIMENTAL_XDS_EXT_PROC_ON_CLIENT")) {
       registry.RegisterFilter(std::make_unique<XdsHttpExtProcFilterFactory>());
     }
-    MutexLock lock(g_mu);
+    MutexLock lock(*g_mu);
     if (*g_http_filter_factory_test_init != nullptr) {
       (*g_http_filter_factory_test_init)(registry);
     }

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

@@ -286,7 +286,7 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   }
   // Otherwise, check the global map to see if the XdsClient instance
   // for this key already exists.
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   auto it = g_xds_client_map->find(key);
   if (it != g_xds_client_map->end()) {
     auto xds_client = it->second->RefIfNonZero(DEBUG_LOCATION, reason);
@@ -370,7 +370,7 @@ void GrpcXdsClient::Orphaned() {
   registered_metric_callback_.reset();
   XdsClient::Orphaned();
   lrs_client_.reset();
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   if (g_inhibit_map_removal) return;
   auto it = g_xds_client_map->find(key_);
   if (it != g_xds_client_map->end() && it->second == this) {
@@ -392,7 +392,7 @@ grpc_pollset_set* GrpcXdsClient::interested_parties() const {
 namespace {
 
 std::vector<RefCountedPtr<GrpcXdsClient>> GetAllXdsClients() {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   std::vector<RefCountedPtr<GrpcXdsClient>> xds_clients;
   for (const auto& [_, client] : *g_xds_client_map) {
     auto xds_client =
@@ -437,7 +437,7 @@ grpc_slice GrpcXdsClient::DumpAllClientConfigs()
 }
 
 void GrpcXdsClient::ReportCallbackMetrics(CallbackMetricReporter& reporter) {
-  MutexLock lock(mu());
+  MutexLock lock(*mu());
   ReportResourceCounts([&](const ResourceCountLabels& labels, uint64_t count) {
     reporter.Report(
         kMetricResources, count,
@@ -452,23 +452,23 @@ void GrpcXdsClient::ReportCallbackMetrics(CallbackMetricReporter& reporter) {
 namespace internal {
 
 void SetXdsChannelArgsForTest(grpc_channel_args* args) {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   g_channel_args = args;
 }
 
 void SetInhibitXdsClientMapRemovalForTest(bool inhibit) {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   g_inhibit_map_removal = inhibit;
 }
 
 void UnsetGlobalXdsClientsForTest() {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   g_xds_client_map->clear();
   g_parsed_bootstrap->reset();
 }
 
 void SetXdsFallbackBootstrapConfig(const char* config) {
-  MutexLock lock(g_mu);
+  MutexLock lock(*g_mu);
   gpr_free(g_fallback_bootstrap_config);
   g_fallback_bootstrap_config = gpr_strdup(config);
 }

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

@@ -22,11 +22,11 @@
 #include <utility>
 #include <variant>
 
+#include "grpc/lookup/v1/rls_config.upb.h"
+#include "grpc/lookup/v1/rls_config.upbdefs.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_reader.h"
-#include "src/proto/grpc/lookup/v1/rls_config.upb.h"
-#include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
 #include "upb/base/status.hpp"
 #include "upb/json/encode.h"
 #include "upb/mem/arena.hpp"

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

@@ -68,7 +68,7 @@ bool XdsEndpointResource::DropConfig::ShouldDrop(
   for (const auto& drop_category : drop_category_list_) {
     // Generate a random number in [0, 1000000).
     const uint32_t random = [&]() {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       return absl::Uniform<uint32_t>(bit_gen_, 0, 1000000);
     }();
     if (random < drop_category.parts_per_million) {

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

@@ -354,6 +354,17 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
           LocalityParse(context, endpoints[i], &address_set, &errors);
       if (parsed_locality.has_value()) {
         GRPC_CHECK_NE(parsed_locality->locality.lb_weight, 0u);
+        // Priorities must be contiguous starting from 0. That is fully
+        // validated below once all localities have been seen, since they may
+        // arrive in any order. Here we only reject priorities that can never
+        // satisfy it, which also bounds the size of the priorities list.
+        if (parsed_locality->priority >= locality_size) {
+          ValidationErrors::ScopedField field(&errors, ".priority");
+          errors.AddError(absl::StrCat("priority ", parsed_locality->priority,
+                                       " >= number of localities (",
+                                       locality_size, ")"));
+          continue;
+        }
         // Make sure priorities is big enough. Note that they might not
         // arrive in priority order.
         if (eds_resource->priorities.size() < parsed_locality->priority + 1) {

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

@@ -46,7 +46,7 @@ GrpcXdsServerTarget ParseXdsGrpcService(
                                /*call_creds_configs=*/{});
   }
   // timeout
-  Duration timeout = Duration::Zero();
+  Duration timeout = Duration::Infinity();
   if (auto* timeout_proto =
           envoy_config_core_v3_GrpcService_timeout(grpc_service);
       timeout_proto != nullptr) {
@@ -58,15 +58,17 @@ GrpcXdsServerTarget ParseXdsGrpcService(
   }
   // initial_metadata
   std::vector<std::pair<std::string, std::string>> initial_metadata;
-  size_t initial_metadata_size;
-  auto* initial_metadata_proto =
-      envoy_config_core_v3_GrpcService_initial_metadata(grpc_service,
-                                                        &initial_metadata_size);
-  for (size_t i = 0; i < initial_metadata_size; ++i) {
-    ValidationErrors::ScopedField field(
-        errors, absl::StrCat(".initial_metadata[", i, "]"));
-    initial_metadata.push_back(
-        ParseXdsHeader(initial_metadata_proto[i], errors));
+  if (DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
+    size_t initial_metadata_size;
+    auto* initial_metadata_proto =
+        envoy_config_core_v3_GrpcService_initial_metadata(
+            grpc_service, &initial_metadata_size);
+    for (size_t i = 0; i < initial_metadata_size; ++i) {
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".initial_metadata[", i, "]"));
+      initial_metadata.push_back(
+          ParseXdsHeader(initial_metadata_proto[i], errors));
+    }
   }
   // google_grpc
   ValidationErrors::ScopedField field(errors, ".google_grpc");

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

@@ -70,8 +70,15 @@ const grpc_channel_filter* XdsHttpExtProcFilterFactory::channel_filter() const {
 
 namespace {
 
-bool ParseHeaderProcessingMode(int32_t value, ValidationErrors* errors) {
+// Parses a ProcessingMode.HeaderSendMode value.  Returns true if the headers
+// or trailers should be sent to the ext_proc server.  DEFAULT resolves to
+// default_value, which per the proto docs is SEND for request and response
+// headers and SKIP for trailers.
+bool ParseHeaderProcessingMode(int32_t value, bool default_value,
+                               ValidationErrors* errors) {
   switch (value) {
+    case envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_DEFAULT:
+      return default_value;
     case envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_SEND:
       return true;
     case envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_SKIP:
@@ -100,30 +107,27 @@ ExtProcFilter::ProcessingMode ParseProcessingMode(
     const envoy_extensions_filters_http_ext_proc_v3_ProcessingMode* proto,
     ValidationErrors* errors) {
   ExtProcFilter::ProcessingMode processing_mode;
-  if (proto == nullptr) {
-    errors->AddError("field not set");
-    return processing_mode;
-  }
+  if (proto == nullptr) return processing_mode;
   {
     ValidationErrors::ScopedField field(errors, ".request_header_mode");
     processing_mode.send_request_headers = ParseHeaderProcessingMode(
         envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_request_header_mode(
             proto),
-        errors);
+        /*default_value=*/true, errors);
   }
   {
     ValidationErrors::ScopedField field(errors, ".response_header_mode");
     processing_mode.send_response_headers = ParseHeaderProcessingMode(
         envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_response_header_mode(
             proto),
-        errors);
+        /*default_value=*/true, errors);
   }
   {
     ValidationErrors::ScopedField field(errors, ".response_trailer_mode");
     processing_mode.send_response_trailers = ParseHeaderProcessingMode(
         envoy_extensions_filters_http_ext_proc_v3_ProcessingMode_response_trailer_mode(
             proto),
-        errors);
+        /*default_value=*/false, errors);
   }
   {
     ValidationErrors::ScopedField field(errors, ".request_body_mode");
@@ -403,13 +407,12 @@ RefCountedPtr<const FilterConfig> XdsHttpExtProcFilterFactory::MergeConfigs(
   if (const auto* target =
           std::get_if<GrpcXdsServerTarget>(&config->channel_info);
       target != nullptr) {
-    std::string key = target->Key();
-    config->channel_info =
-        blackboard.GetOrSet<ExtProcFilter::ExtProcChannel>(key, [&]() {
-          std::shared_ptr<const XdsBootstrap::XdsServerTarget> target_shared =
-              std::make_shared<GrpcXdsServerTarget>(*target);
+    config->channel_info = blackboard.GetOrSet<ExtProcFilter::ExtProcChannel>(
+        target->Key(), [&]() {
+          absl::Status status;
+          auto transport = transport_factory.GetTransport(*target, &status);
           return MakeRefCounted<ExtProcFilter::ExtProcChannel>(
-              std::move(target_shared), transport_factory.Ref());
+              *target, std::move(transport));
         });
   }
   return config;

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

@@ -196,7 +196,7 @@ class XdsMatcherList : public XdsMatcher {
 
   // Factory method for creating a SinglePredicate.
   template <typename InputType, typename MatcherType>
-  static absl::enable_if_t<
+  static std::enable_if_t<
       std::is_same<typename InputType::ProducedType,
                    typename MatcherType::ConsumedType>::value,
       std::unique_ptr<Predicate>>
@@ -210,7 +210,7 @@ class XdsMatcherList : public XdsMatcher {
   // Alternative template specialization to return null in the case where
   // the input produces a different type than the matcher consumes.
   template <typename InputType, typename MatcherType>
-  static absl::enable_if_t<
+  static std::enable_if_t<
       !std::is_same<typename InputType::ProducedType,
                     typename MatcherType::ConsumedType>::value,
       std::unique_ptr<Predicate>>