grpc 1.69.0 → 1.71.0

data/src/core/telemetry/call_tracer.h

@@ -23,17 +23,18 @@
 #include <grpc/support/time.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/call_final_info.h"
+#include "src/core/lib/transport/message.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/ref_counted_string.h"
@@ -95,19 +96,19 @@ class CallTracerInterface : public CallTracerAnnotationInterface {
       grpc_metadata_batch* send_initial_metadata) = 0;
   virtual void RecordSendTrailingMetadata(
       grpc_metadata_batch* send_trailing_metadata) = 0;
-  virtual void RecordSendMessage(const SliceBuffer& send_message) = 0;
+  virtual void RecordSendMessage(const Message& send_message) = 0;
   // Only invoked if message was actually compressed.
   virtual void RecordSendCompressedMessage(
-      const SliceBuffer& send_compressed_message) = 0;
+      const Message& send_compressed_message) = 0;
   // The `RecordReceivedInitialMetadata()` and `RecordReceivedMessage()`
   // methods should only be invoked when the metadata/message was
   // successfully received, i.e., without any error.
   virtual void RecordReceivedInitialMetadata(
       grpc_metadata_batch* recv_initial_metadata) = 0;
-  virtual void RecordReceivedMessage(const SliceBuffer& recv_message) = 0;
+  virtual void RecordReceivedMessage(const Message& recv_message) = 0;
   // Only invoked if message was actually decompressed.
   virtual void RecordReceivedDecompressedMessage(
-      const SliceBuffer& recv_decompressed_message) = 0;
+      const Message& recv_decompressed_message) = 0;
   virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
 
   struct TransportByteSize {

data/src/core/telemetry/metrics.cc

@@ -17,9 +17,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {
@@ -164,7 +164,7 @@ GlobalStatsPluginRegistry::GetStatsPluginsForServer(const ChannelArgs& args) {
   return group;
 }
 
-absl::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
+std::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
 GlobalInstrumentsRegistry::FindInstrumentByName(absl::string_view name) {
   const auto& instruments = GetInstrumentList();
   for (const auto& descriptor : instruments) {
@@ -174,7 +174,7 @@ GlobalInstrumentsRegistry::FindInstrumentByName(absl::string_view name) {
       return handle;
     }
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/telemetry/metrics.h

@@ -209,7 +209,7 @@ class GlobalInstrumentsRegistry {
       absl::FunctionRef<void(const GlobalInstrumentDescriptor&)> f);
   static const GlobalInstrumentDescriptor& GetInstrumentDescriptor(
       GlobalInstrumentHandle handle);
-  static absl::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
+  static std::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
   FindInstrumentByName(absl::string_view name);
 
  private:
@@ -479,7 +479,6 @@ class GlobalStatsPluginRegistry {
       std::shared_ptr<StatsPlugin> plugin;
     };
 
-    // C++17 has fold expression that may simplify this.
     template <GlobalInstrumentsRegistry::ValueType V,
               GlobalInstrumentsRegistry::InstrumentType I, size_t M, size_t N>
     static constexpr void AssertIsCallbackGaugeHandle(
@@ -491,11 +490,6 @@ class GlobalStatsPluginRegistry {
           I == GlobalInstrumentsRegistry::InstrumentType::kCallbackGauge,
           "InstrumentType must be kCallbackGauge");
     }
-    template <typename T, typename... Args>
-    static constexpr void AssertIsCallbackGaugeHandle(T t, Args&&... args) {
-      AssertIsCallbackGaugeHandle(t);
-      AssertIsCallbackGaugeHandle(args...);
-    }
 
     std::vector<PluginState> plugins_state_;
   };
@@ -557,7 +551,7 @@ inline std::unique_ptr<RegisteredMetricCallback>
 GlobalStatsPluginRegistry::StatsPluginGroup::RegisterCallback(
     absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
     Duration min_interval, Args... args) {
-  AssertIsCallbackGaugeHandle(args...);
+  (AssertIsCallbackGaugeHandle(args), ...);
   return std::make_unique<RegisteredMetricCallback>(
       *this, std::move(callback),
       std::vector<GlobalInstrumentsRegistry::GlobalInstrumentHandle>{args...},

data/src/core/telemetry/tcp_tracer.h

@@ -23,10 +23,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 
@@ -53,87 +53,87 @@ class TcpTracerInterface {
     // Congestion control name.
     std::string congestion_ctrl;
     // Delivery rate in Bps.
-    absl::optional<uint64_t> delivery_rate;
+    std::optional<uint64_t> delivery_rate;
     // Total bytes retransmitted so far.
-    absl::optional<uint64_t> data_retx;
+    std::optional<uint64_t> data_retx;
     // Total bytes sent so far.
-    absl::optional<uint64_t> data_sent;
+    std::optional<uint64_t> data_sent;
     // Total packets lost so far.
     // Includes lost or spuriously retransmitted packets.
-    absl::optional<uint32_t> packet_retx;
+    std::optional<uint32_t> packet_retx;
     // Total packets spuriously retransmitted so far.
-    absl::optional<uint32_t> packet_spurious_retx;
+    std::optional<uint32_t> packet_spurious_retx;
     // Total packets sent so far.
-    absl::optional<uint32_t> packet_sent;
+    std::optional<uint32_t> packet_sent;
     // Total packets delivered so far.
-    absl::optional<uint32_t> packet_delivered;
+    std::optional<uint32_t> packet_delivered;
     // Total packets delivered so far with ECE marked.
     // This metric is smaller than or equal to packet_delivered.
-    absl::optional<uint32_t> packet_delivered_ce;
+    std::optional<uint32_t> packet_delivered_ce;
     // Total bytes in write queue but not sent.
-    absl::optional<uint64_t> data_notsent;
+    std::optional<uint64_t> data_notsent;
     // Minimum RTT observed in usec.
-    absl::optional<uint32_t> min_rtt;
+    std::optional<uint32_t> min_rtt;
     // Smoothed RTT in usec
-    absl::optional<uint32_t> srtt;
+    std::optional<uint32_t> srtt;
     // TTL or hop limit of a packet received
     // Only available with ACKED timestamps.
-    absl::optional<uint32_t> ttl;
+    std::optional<uint32_t> ttl;
     // Represents the number of recurring retransmissions of
     // the first sequence that is not acknowledged yet.
-    absl::optional<uint32_t> recurring_retrans;
+    std::optional<uint32_t> recurring_retrans;
     // Network RTT using hardware timestamps (in usec).
     // A value of -1 indicates that net_rtt could not be measured.
-    absl::optional<int32_t> net_rtt_usec;
+    std::optional<int32_t> net_rtt_usec;
     // Timeout-triggered rehash attempts.
-    absl::optional<uint32_t> timeout_rehash;
+    std::optional<uint32_t> timeout_rehash;
     // Rehash due to ECN congestion.
-    absl::optional<uint32_t> ecn_rehash;
+    std::optional<uint32_t> ecn_rehash;
     // Earliest departure time (CLOCK_MONOTONIC).
     // Only available with SCHEDULED and SENT timestamps.
-    absl::optional<uint64_t> edt;
+    std::optional<uint64_t> edt;
     // If the delivery rate is limited by the application, this is set to
     // true.
-    absl::optional<bool> is_delivery_rate_app_limited;
+    std::optional<bool> is_delivery_rate_app_limited;
     // Pacing rate of the connection in Bps.
-    absl::optional<uint64_t> pacing_rate;
+    std::optional<uint64_t> pacing_rate;
     // Send congestion window in packets.
-    absl::optional<uint32_t> congestion_window;
+    std::optional<uint32_t> congestion_window;
     // Maximum degree of reordering (i.e., maximum number of packets reodered)
     // on the connection.
-    absl::optional<uint32_t> reordering;
+    std::optional<uint32_t> reordering;
     // Cumulative duration (in usec) that the transport protocol
     // was busy sending time.
-    absl::optional<uint64_t> busy_usec;
+    std::optional<uint64_t> busy_usec;
     // Cumulative duration (in usec) that the transport protocol
     // was limited by the receive window size.
-    absl::optional<uint64_t> rwnd_limited_usec;
+    std::optional<uint64_t> rwnd_limited_usec;
     // Cumulative duration (in usec) that the transport protocol
     // was limited by the send buffer size.
-    absl::optional<uint64_t> sndbuf_limited_usec;
+    std::optional<uint64_t> sndbuf_limited_usec;
     // Slow start size threshold in packets.
     // Set to TCP_INFINITE_SSTHRESH when still in slow start.
-    absl::optional<uint32_t> snd_ssthresh;
+    std::optional<uint32_t> snd_ssthresh;
     // The extra time it takes for the receiver to generate the
     // acknowledgement after receiving the last packet. This metric is not
     // cumulative. Only available with ACKED timestamps.
-    absl::optional<uint32_t> time_to_ack_usec;
+    std::optional<uint32_t> time_to_ack_usec;
     // Last socket error code. Only populated for CLOSED timestamps.
-    absl::optional<uint32_t> socket_errno;
+    std::optional<uint32_t> socket_errno;
     // Peer's receive window after scaling (tcpi_snd_wnd).
     // Only available with SENDMSG timestamps.
-    absl::optional<uint32_t> peer_rwnd;
+    std::optional<uint32_t> peer_rwnd;
     // Receive queue drops.
-    absl::optional<uint32_t> rcvq_drops;
+    std::optional<uint32_t> rcvq_drops;
     // The NIC Rx delay reported by the remote host.
-    absl::optional<uint32_t> nic_rx_delay_usec;
+    std::optional<uint32_t> nic_rx_delay_usec;
   };
 
   virtual ~TcpTracerInterface() = default;
   // Records a per-message event with an optional snapshot of connection
   // metrics.
   virtual void RecordEvent(Type type, absl::Time time, size_t byte_offset,
-                           absl::optional<ConnectionMetrics> metrics) = 0;
+                           std::optional<ConnectionMetrics> metrics) = 0;
   // Records a snapshot of connection metrics.
   virtual void RecordConnectionMetrics(ConnectionMetrics metrics) = 0;
 };

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -298,7 +298,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     if (details.size > 0) {
       error = absl::StrCat("Status ", code, " from handshaker service: ",
                            absl::string_view(details.data, details.size));
-      LOG(ERROR) << error;
+      LOG_EVERY_N_SEC(INFO, 1) << error;
     }
   }
   // TODO(apolcyn): consider short ciruiting handle_response_done and
@@ -744,7 +744,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
                 /*cq=*/nullptr, interested_parties,
                 grpc_core::Slice::FromStaticString(ALTS_SERVICE_METHOD),
-                /*authority=*/absl::nullopt, grpc_core::Timestamp::InfFuture(),
+                /*authority=*/std::nullopt, grpc_core::Timestamp::InfFuture(),
                 /*registered_method=*/true);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
@@ -930,7 +930,7 @@ void alts_handshaker_client_destroy(alts_handshaker_client* c) {
 
 size_t MaxNumberOfConcurrentHandshakes() {
   size_t max_concurrent_handshakes = 100;
-  absl::optional<std::string> env_var_max_concurrent_handshakes =
+  std::optional<std::string> env_var_max_concurrent_handshakes =
       grpc_core::GetEnv(kMaxConcurrentStreamsEnvironmentVariable);
   if (env_var_max_concurrent_handshakes.has_value()) {
     size_t effective_max_concurrent_handshakes = 100;

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -347,22 +347,22 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     return TSI_FAILED_PRECONDITION;
   }
   if (grpc_gcp_Identity_attributes_size(identity) != 0) {
-    size_t iter = kUpb_Map_Begin;
-    grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
-        grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
-    while (peer_attributes_entry != nullptr) {
-      upb_StringView key = grpc_gcp_Identity_AttributesEntry_key(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      upb_StringView val = grpc_gcp_Identity_AttributesEntry_value(
-          const_cast<grpc_gcp_Identity_AttributesEntry*>(
-              peer_attributes_entry));
-      grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
-                                               context_arena.ptr());
-      peer_attributes_entry =
-          grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
+    // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+    // v30.0.
+    const upb_Map* upb_map =
+        _grpc_gcp_Identity_attributes_upb_map(peer_identity);
+    if (upb_map) {
+      size_t iter = kUpb_Map_Begin;
+      upb_MessageValue k, v;
+      while (upb_Map_Next(upb_map, &k, &v, &iter)) {
+        upb_StringView key = k.str_val;
+        upb_StringView val = v.str_val;
+        grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
+                                                 context_arena.ptr());
+      }
     }
   }
+
   size_t serialized_ctx_length;
   char* serialized_ctx = grpc_gcp_AltsContext_serialize(
       context, context_arena.ptr(), &serialized_ctx_length);

data/src/core/tsi/fake_transport_security.cc

@@ -191,6 +191,11 @@ static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
     frame->allocated_size = TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE;
     frame->data =
         static_cast<unsigned char*>(gpr_malloc(frame->allocated_size));
+    // Initialize `data` to some recognizably bad values.
+    // There's some debug code paths where we stringify the entire buffer, and
+    // doing so leads to ubsan failures on those code paths -- which are
+    // commonly hit using fuzzers.
+    memset(frame->data, 0xab, frame->allocated_size);
   }
 
   if (frame->offset < TSI_FAKE_FRAME_HEADER_SIZE) {

data/src/core/util/backoff.cc

@@ -22,16 +22,27 @@
 
 #include <algorithm>
 
+#include "src/core/lib/experiments/experiments.h"
+
 namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
 Duration BackOff::NextAttemptDelay() {
-  if (initial_) {
-    initial_ = false;
+  if (IsBackoffCapInitialAtMaxEnabled()) {
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ *= options_.multiplier();
+    }
+    current_backoff_ = std::min(current_backoff_, options_.max_backoff());
   } else {
-    current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
-                                options_.max_backoff());
+    if (initial_) {
+      initial_ = false;
+    } else {
+      current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                                  options_.max_backoff());
+    }
   }
   const double jitter =
       absl::Uniform(rand_gen_, 1 - options_.jitter(), 1 + options_.jitter());

data/src/core/util/dump_args.h

@@ -26,20 +26,12 @@
 namespace grpc_core {
 namespace dump_args_detail {
 
-// Helper function... just ignore the initializer list passed into it.
-// Allows doing 'statements' via parameter pack expansion in C++11 - given
-// template <typename... Ts>:
-//  do_these_things({foo<Ts>()...});
-// will execute foo<T>() for each T in Ts.
-template <typename T>
-void do_these_things(std::initializer_list<T>) {}
-
 class DumpArgs {
  public:
   template <typename... Args>
   explicit DumpArgs(const char* arg_string, const Args&... args)
       : arg_string_(arg_string) {
-    do_these_things({AddDumper(&args)...});
+    (AddDumper(&args), ...);
   }
 
   template <typename Sink>

data/src/core/util/env.h

@@ -21,14 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 // Gets the environment variable value with the specified name. */
-absl::optional<std::string> GetEnv(const char* name);
+std::optional<std::string> GetEnv(const char* name);
 
 // Sets the environment with the specified name to the specified value.
 void SetEnv(const char* name, const char* value);
@@ -40,7 +39,7 @@ inline void SetEnv(const char* name, const std::string& value) {
 void UnsetEnv(const char* name);
 
 template <typename T>
-void SetOrUnsetEnv(const char* name, const absl::optional<T>& value) {
+void SetOrUnsetEnv(const char* name, const std::optional<T>& value) {
   if (value.has_value()) {
     SetEnv(name, value.value());
   } else {

data/src/core/util/examine_stack.cc

@@ -33,11 +33,11 @@ void SetCurrentStackTraceProvider(
   g_current_stack_trace_provider = current_stack_trace_provider;
 }
 
-absl::optional<std::string> GetCurrentStackTrace() {
+std::optional<std::string> GetCurrentStackTrace() {
   if (g_current_stack_trace_provider != nullptr) {
     return g_current_stack_trace_provider();
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/util/examine_stack.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 typedef std::string (*gpr_current_stack_trace_func)();
@@ -37,8 +36,8 @@ void SetCurrentStackTraceProvider(
     gpr_current_stack_trace_func current_stack_trace_provider);
 
 // Returns the current stack trace as a string via current_stack_trace_provider
-// If current_stack_trace_provider is not set, it returns absl::nullopt.
-absl::optional<std::string> GetCurrentStackTrace();
+// If current_stack_trace_provider is not set, it returns std::nullopt.
+std::optional<std::string> GetCurrentStackTrace();
 
 }  // namespace grpc_core
 

data/src/core/util/gpr_time.cc

@@ -18,7 +18,6 @@
 
 // Generic implementation of time calls.
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 #include <limits.h>
@@ -26,7 +25,6 @@
 #include <string.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);

data/src/core/util/http_client/httpcli.cc

@@ -35,9 +35,10 @@
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/event_engine/resolved_address_internal.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -55,6 +56,9 @@ namespace grpc_core {
 
 namespace {
 
+using grpc_event_engine::experimental::EventEngine;
+using grpc_event_engine::experimental::ResolvedAddressToURI;
+
 grpc_httpcli_get_override g_get_override;
 grpc_httpcli_post_override g_post_override;
 grpc_httpcli_put_override g_put_override;
@@ -67,7 +71,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_get_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -93,7 +97,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_post_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -118,7 +122,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_put_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -155,7 +159,7 @@ HttpRequest::HttpRequest(
     URI uri, const grpc_slice& request_text, grpc_http_response* response,
     Timestamp deadline, const grpc_channel_args* channel_args,
     grpc_closure* on_done, grpc_polling_entity* pollent, const char* name,
-    absl::optional<std::function<bool()>> test_only_generate_response,
+    std::optional<std::function<bool()>> test_only_generate_response,
     RefCountedPtr<grpc_channel_credentials> channel_creds)
     : uri_(std::move(uri)),
       request_text_(request_text),
@@ -171,7 +175,15 @@ HttpRequest::HttpRequest(
       pollent_(pollent),
       pollset_set_(grpc_pollset_set_create()),
       test_only_generate_response_(std::move(test_only_generate_response)),
-      resolver_(GetDNSResolver()) {
+      use_event_engine_dns_resolver_(IsEventEngineDnsNonClientChannelEnabled()),
+      resolver_(!use_event_engine_dns_resolver_ ? GetDNSResolver() : nullptr),
+      ee_resolver_(
+          use_event_engine_dns_resolver_
+              ? ChannelArgs::FromC(channel_args_)
+                    .GetObjectRef<EventEngine>()
+                    ->GetDNSResolver(
+                        EventEngine::DNSResolver::ResolverOptions())
+              : absl::InternalError("EventEngine DNS is not enabled")) {
   grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
   grpc_slice_buffer_init(&incoming_);
   grpc_slice_buffer_init(&outgoing_);
@@ -204,11 +216,38 @@ void HttpRequest::Start() {
   if (test_only_generate_response_.has_value()) {
     if (test_only_generate_response_.value()()) return;
   }
+  if (use_event_engine_dns_resolver_ && !ee_resolver_.ok()) {
+    Finish(ee_resolver_.status());
+    return;
+  }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_handle_ = resolver_->LookupHostname(
-      absl::bind_front(&HttpRequest::OnResolved, this), uri_.authority(),
-      uri_.scheme(), kDefaultDNSRequestTimeout, pollset_set_,
-      /*name_server=*/"");
+  if (use_event_engine_dns_resolver_) {
+    (*ee_resolver_)
+        ->LookupHostname(
+            [this](absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+                       addresses_or) {
+              ExecCtx exec_ctx;
+              OnResolved(addresses_or);
+            },
+            uri_.authority(), uri_.scheme());
+  } else {
+    dns_request_handle_ = resolver_->LookupHostname(
+        [this](absl::StatusOr<std::vector<grpc_resolved_address>> addresses) {
+          if (addresses.ok()) {
+            std::vector<EventEngine::ResolvedAddress> ee_addresses;
+            for (const auto& addr : *addresses) {
+              ee_addresses.push_back(
+                  grpc_event_engine::experimental::CreateResolvedAddress(addr));
+            }
+            OnResolved(ee_addresses);
+          } else {
+            OnResolved(addresses.status());
+          }
+        },
+        uri_.authority(), uri_.scheme(), kDefaultDNSRequestTimeout,
+        pollset_set_,
+        /*name_server=*/"");
+  }
 }
 
 void HttpRequest::Orphan() {
@@ -217,10 +256,16 @@ void HttpRequest::Orphan() {
     CHECK(!cancelled_);
     cancelled_ = true;
     // cancel potentially pending DNS resolution.
-    if (dns_request_handle_.has_value() &&
-        resolver_->Cancel(dns_request_handle_.value())) {
-      Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
-      Unref();
+    if (use_event_engine_dns_resolver_) {
+      if (*ee_resolver_ != nullptr) {
+        ee_resolver_->reset();
+      }
+    } else {
+      if (dns_request_handle_.has_value() &&
+          resolver_->Cancel(dns_request_handle_.value())) {
+        Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
+        Unref();
+      }
     }
     if (handshake_mgr_ != nullptr) {
       // Shutdown will cancel any ongoing tcp connect.
@@ -236,8 +281,7 @@ void HttpRequest::AppendError(grpc_error_handle error) {
   if (overall_error_.ok()) {
     overall_error_ = GRPC_ERROR_CREATE("Failed HTTP/1 client request");
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
-  auto addr_text = grpc_sockaddr_to_uri(addr);
+  auto addr_text = ResolvedAddressToURI(addresses_[next_address_ - 1]);
   if (addr_text.ok()) error = AddMessagePrefix(*addr_text, std::move(error));
   overall_error_ = grpc_error_add_child(overall_error_, std::move(error));
 }
@@ -311,7 +355,7 @@ void HttpRequest::OnHandshakeDone(absl::StatusOr<HandshakerArgs*> result) {
   StartWrite();
 }
 
-void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
+void HttpRequest::DoHandshake(const EventEngine::ResolvedAddress& addr) {
   // Create the security connector using the credentials and target name.
   ChannelArgs args = ChannelArgs::FromC(channel_args_);
   RefCountedPtr<grpc_channel_security_connector> sc =
@@ -322,7 +366,7 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
                                          &overall_error_, 1));
     return;
   }
-  absl::StatusOr<std::string> address = grpc_sockaddr_to_uri(addr);
+  absl::StatusOr<std::string> address = ResolvedAddressToURI(addr);
   if (!address.ok()) {
     Finish(GRPC_ERROR_CREATE_REFERENCING("Failed to extract URI from address",
                                          &overall_error_, 1));
@@ -355,15 +399,18 @@ void HttpRequest::NextAddress(grpc_error_handle error) {
                                          &overall_error_, 1));
     return;
   }
-  const grpc_resolved_address* addr = &addresses_[next_address_++];
-  DoHandshake(addr);
+  DoHandshake(addresses_[next_address_++]);
 }
 
 void HttpRequest::OnResolved(
-    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+    absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses_or) {
   RefCountedPtr<HttpRequest> unreffer(this);
   MutexLock lock(&mu_);
-  dns_request_handle_.reset();
+  if (use_event_engine_dns_resolver_) {
+    ee_resolver_->reset();
+  } else {
+    dns_request_handle_.reset();
+  }
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE("cancelled during DNS resolution"));
     return;