grpc 1.60.2 → 1.61.0.pre2

data/src/core/lib/gprpp/ref_counted.h

@@ -219,7 +219,7 @@ class NonPolymorphicRefCount {
 // Default behavior: Delete the object.
 struct UnrefDelete {
   template <typename T>
-  void operator()(T* p) {
+  void operator()(T* p) const {
     delete p;
   }
 };
@@ -231,7 +231,7 @@ struct UnrefDelete {
 // later by identifying entries for which RefIfNonZero() returns null.
 struct UnrefNoDelete {
   template <typename T>
-  void operator()(T* /*p*/) {}
+  void operator()(T* /*p*/) const {}
 };
 
 // Call the object's dtor but do not delete it.  This is useful for cases
@@ -239,7 +239,7 @@ struct UnrefNoDelete {
 // arena).
 struct UnrefCallDtor {
   template <typename T>
-  void operator()(T* p) {
+  void operator()(T* p) const {
     p->~T();
   }
 };
@@ -276,35 +276,52 @@ class RefCounted : public Impl {
  public:
   using RefCountedChildType = Child;
 
+  // Not copyable nor movable.
+  RefCounted(const RefCounted&) = delete;
+  RefCounted& operator=(const RefCounted&) = delete;
+
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~RefCounted() = default;
 
+  // Ref() for mutable types.
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref() {
     IncrementRefCount();
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
-
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> Ref(const DebugLocation& location,
                                                 const char* reason) {
     IncrementRefCount(location, reason);
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
-  // TODO(roth): Once all of our code is converted to C++ and can use
-  // RefCountedPtr<> instead of manual ref-counting, make this method
-  // private, since it will only be used by RefCountedPtr<>, which is a
-  // friend of this class.
-  void Unref() {
-    if (GPR_UNLIKELY(refs_.Unref())) {
-      unref_behavior_(static_cast<Child*>(this));
-    }
+  // Ref() for const types.
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> Ref() const {
+    IncrementRefCount();
+    return RefCountedPtr<const Child>(static_cast<const Child*>(this));
   }
-  void Unref(const DebugLocation& location, const char* reason) {
-    if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      unref_behavior_(static_cast<Child*>(this));
-    }
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> Ref(
+      const DebugLocation& location, const char* reason) const {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<const Child>(static_cast<const Child*>(this));
+  }
+
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass() {
+    IncrementRefCount();
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
+  }
+  template <
+      typename Subclass,
+      std::enable_if_t<std::is_base_of<Child, Subclass>::value, bool> = true>
+  RefCountedPtr<Subclass> RefAsSubclass(const DebugLocation& location,
+                                        const char* reason) {
+    IncrementRefCount(location, reason);
+    return RefCountedPtr<Subclass>(static_cast<Subclass*>(this));
   }
 
+  // RefIfNonZero() for mutable types.
   GRPC_MUST_USE_RESULT RefCountedPtr<Child> RefIfNonZero() {
     return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this)
                                                      : nullptr);
@@ -316,9 +333,32 @@ class RefCounted : public Impl {
                                     : nullptr);
   }
 
-  // Not copyable nor movable.
-  RefCounted(const RefCounted&) = delete;
-  RefCounted& operator=(const RefCounted&) = delete;
+  // RefIfNonZero() for const types.
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> RefIfNonZero() const {
+    return RefCountedPtr<const Child>(
+        refs_.RefIfNonZero() ? static_cast<const Child*>(this) : nullptr);
+  }
+  GRPC_MUST_USE_RESULT RefCountedPtr<const Child> RefIfNonZero(
+      const DebugLocation& location, const char* reason) const {
+    return RefCountedPtr<const Child>(refs_.RefIfNonZero(location, reason)
+                                          ? static_cast<const Child*>(this)
+                                          : nullptr);
+  }
+
+  // TODO(roth): Once all of our code is converted to C++ and can use
+  // RefCountedPtr<> instead of manual ref-counting, make this method
+  // private, since it will only be used by RefCountedPtr<>, which is a
+  // friend of this class.
+  void Unref() const {
+    if (GPR_UNLIKELY(refs_.Unref())) {
+      unref_behavior_(static_cast<const Child*>(this));
+    }
+  }
+  void Unref(const DebugLocation& location, const char* reason) const {
+    if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
+      unref_behavior_(static_cast<const Child*>(this));
+    }
+  }
 
  protected:
   // Note: Tracing is a no-op on non-debug builds.
@@ -336,12 +376,13 @@ class RefCounted : public Impl {
   template <typename T>
   friend class RefCountedPtr;
 
-  void IncrementRefCount() { refs_.Ref(); }
-  void IncrementRefCount(const DebugLocation& location, const char* reason) {
+  void IncrementRefCount() const { refs_.Ref(); }
+  void IncrementRefCount(const DebugLocation& location,
+                         const char* reason) const {
     refs_.Ref(location, reason);
   }
 
-  RefCount refs_;
+  mutable RefCount refs_;
   GPR_NO_UNIQUE_ADDRESS UnrefBehavior unref_behavior_;
 };
 

data/src/core/lib/gprpp/ref_counted_ptr.h

@@ -43,7 +43,8 @@ class RefCountedPtr {
   RefCountedPtr(std::nullptr_t) {}
 
   // If value is non-null, we take ownership of a ref to it.
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   explicit RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
@@ -51,7 +52,8 @@ class RefCountedPtr {
     value_ = other.value_;
     other.value_ = nullptr;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   RefCountedPtr(RefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
@@ -63,7 +65,8 @@ class RefCountedPtr {
     reset(std::exchange(other.value_, nullptr));
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   RefCountedPtr& operator=(RefCountedPtr<Y>&& other) noexcept {
     reset(std::exchange(other.value_, nullptr));
     return *this;
@@ -74,7 +77,8 @@ class RefCountedPtr {
     if (other.value_ != nullptr) other.value_->IncrementRefCount();
     value_ = other.value_;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   RefCountedPtr(const RefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -92,7 +96,8 @@ class RefCountedPtr {
     reset(other.value_);
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   RefCountedPtr& operator=(const RefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
@@ -107,6 +112,12 @@ class RefCountedPtr {
     if (value_ != nullptr) value_->Unref();
   }
 
+  // An explicit copy method that supports ref-count tracing.
+  RefCountedPtr<T> Ref(const DebugLocation& location, const char* reason) {
+    if (value_ != nullptr) value_->IncrementRefCount(location, reason);
+    return RefCountedPtr<T>(value_);
+  }
+
   void swap(RefCountedPtr& other) { std::swap(value_, other.value_); }
 
   // If value is non-null, we take ownership of a ref to it.
@@ -119,13 +130,15 @@ class RefCountedPtr {
     T* old_value = std::exchange(value_, value);
     if (old_value != nullptr) old_value->Unref(location, reason);
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
     reset(static_cast<T*>(value));
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -143,24 +156,34 @@ class RefCountedPtr {
   T& operator*() const { return *value_; }
   T* operator->() const { return value_; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_base_of<T, Y>::value, bool> = true>
+  RefCountedPtr<Y> TakeAsSubclass() {
+    return RefCountedPtr<Y>(static_cast<Y*>(release()));
+  }
+
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const RefCountedPtr<Y>& other) const {
     return value_ == other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const Y* other) const {
     return value_ == other;
   }
 
   bool operator==(std::nullptr_t) const { return value_ == nullptr; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const RefCountedPtr<Y>& other) const {
     return value_ != other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const Y* other) const {
     return value_ != other;
   }
@@ -184,7 +207,8 @@ class WeakRefCountedPtr {
   WeakRefCountedPtr(std::nullptr_t) {}
 
   // If value is non-null, we take ownership of a ref to it.
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   explicit WeakRefCountedPtr(Y* value) {
     value_ = value;
   }
@@ -194,7 +218,8 @@ class WeakRefCountedPtr {
     value_ = other.value_;
     other.value_ = nullptr;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) noexcept {
     value_ = static_cast<T*>(other.value_);
@@ -206,7 +231,8 @@ class WeakRefCountedPtr {
     reset(std::exchange(other.value_, nullptr));
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) noexcept {
     reset(std::exchange(other.value_, nullptr));
     return *this;
@@ -217,7 +243,8 @@ class WeakRefCountedPtr {
     if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
     value_ = other.value_;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   // NOLINTNEXTLINE(google-explicit-constructor)
   WeakRefCountedPtr(const WeakRefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -235,7 +262,8 @@ class WeakRefCountedPtr {
     reset(other.value_);
     return *this;
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   WeakRefCountedPtr& operator=(const WeakRefCountedPtr<Y>& other) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
@@ -250,6 +278,13 @@ class WeakRefCountedPtr {
     if (value_ != nullptr) value_->WeakUnref();
   }
 
+  // An explicit copy method that supports ref-count tracing.
+  WeakRefCountedPtr<T> WeakRef(const DebugLocation& location,
+                               const char* reason) {
+    if (value_ != nullptr) value_->IncrementWeakRefCount(location, reason);
+    return WeakRefCountedPtr<T>(value_);
+  }
+
   void swap(WeakRefCountedPtr& other) { std::swap(value_, other.value_); }
 
   // If value is non-null, we take ownership of a ref to it.
@@ -262,13 +297,15 @@ class WeakRefCountedPtr {
     T* old_value = std::exchange(value_, value);
     if (old_value != nullptr) old_value->WeakUnref(location, reason);
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
     reset(static_cast<T*>(value));
   }
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
@@ -280,35 +317,41 @@ class WeakRefCountedPtr {
   // us to pass a ref to idiomatic C code that does not use WeakRefCountedPtr<>.
   // Once all of our code has been converted to idiomatic C++, this
   // method should go away.
-  T* release() {
-    T* value = value_;
-    value_ = nullptr;
-    return value;
-  }
+  T* release() { return std::exchange(value_, nullptr); }
 
   T* get() const { return value_; }
 
   T& operator*() const { return *value_; }
   T* operator->() const { return value_; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_base_of<T, Y>::value, bool> = true>
+  WeakRefCountedPtr<Y> TakeAsSubclass() {
+    return WeakRefCountedPtr<Y>(static_cast<Y*>(release()));
+  }
+
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const WeakRefCountedPtr<Y>& other) const {
     return value_ == other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator==(const Y* other) const {
     return value_ == other;
   }
 
   bool operator==(std::nullptr_t) const { return value_ == nullptr; }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const WeakRefCountedPtr<Y>& other) const {
     return value_ != other.value_;
   }
 
-  template <typename Y>
+  template <typename Y,
+            std::enable_if_t<std::is_convertible<Y*, T*>::value, bool> = true>
   bool operator!=(const Y* other) const {
     return value_ != other;
   }

data/src/core/lib/gprpp/ref_counted_string.h

@@ -104,6 +104,19 @@ inline bool operator==(const RefCountedStringValue& lhs,
   return lhs.as_string_view() == rhs.as_string_view();
 }
 
+inline bool operator!=(const RefCountedStringValue& lhs,
+                       absl::string_view rhs) {
+  return lhs.as_string_view() != rhs;
+}
+inline bool operator!=(absl::string_view lhs,
+                       const RefCountedStringValue& rhs) {
+  return lhs != rhs.as_string_view();
+}
+inline bool operator!=(const RefCountedStringValue& lhs,
+                       const RefCountedStringValue& rhs) {
+  return lhs.as_string_view() != rhs.as_string_view();
+}
+
 inline bool operator<(const RefCountedStringValue& lhs, absl::string_view rhs) {
   return lhs.as_string_view() < rhs;
 }

data/src/core/lib/gprpp/status_helper.cc

@@ -34,8 +34,7 @@
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
 #include "upb/base/string_view.h"
-#include "upb/mem/arena.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 
 #include <grpc/support/log.h>
 

data/src/core/lib/iomgr/combiner.cc

@@ -51,19 +51,11 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
                                   grpc_closure* closure,
                                   grpc_error_handle error);
 
-// TODO(ctiller): delete this when the combiner_offload_to_event_engine
-// experiment is removed.
-static void offload(void* arg, grpc_error_handle error);
-
 grpc_core::Combiner* grpc_combiner_create(
     std::shared_ptr<grpc_event_engine::experimental::EventEngine>
         event_engine) {
   grpc_core::Combiner* lock = new grpc_core::Combiner();
-  if (grpc_core::IsCombinerOffloadToEventEngineEnabled()) {
-    lock->event_engine = event_engine;
-  } else {
-    GRPC_CLOSURE_INIT(&lock->offload, offload, lock, nullptr);
-  }
+  lock->event_engine = event_engine;
   gpr_ref_init(&lock->refs, 1);
   gpr_atm_no_barrier_store(&lock->state, STATE_UNORPHANED);
   grpc_closure_list_init(&lock->final_list);
@@ -173,27 +165,18 @@ static void move_next() {
   }
 }
 
-static void offload(void* arg, grpc_error_handle /*error*/) {
-  grpc_core::Combiner* lock = static_cast<grpc_core::Combiner*>(arg);
-  push_last_on_exec_ctx(lock);
-}
-
 static void queue_offload(grpc_core::Combiner* lock) {
   move_next();
   // Make the combiner look uncontended by storing a non-null value here, so
   // that we don't immediately offload again.
   gpr_atm_no_barrier_store(&lock->initiating_exec_ctx_or_null, 1);
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
-  if (grpc_core::IsCombinerOffloadToEventEngineEnabled()) {
-    lock->event_engine->Run([lock] {
-      grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-      grpc_core::ExecCtx exec_ctx(0);
-      push_last_on_exec_ctx(lock);
-      exec_ctx.Flush();
-    });
-  } else {
-    grpc_core::Executor::Run(&lock->offload, absl::OkStatus());
-  }
+  lock->event_engine->Run([lock] {
+    grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+    grpc_core::ExecCtx exec_ctx(0);
+    push_last_on_exec_ctx(lock);
+    exec_ctx.Flush();
+  });
 }
 
 bool grpc_combiner_continue_exec_ctx() {
@@ -215,33 +198,14 @@ bool grpc_combiner_continue_exec_ctx() {
                               grpc_core::ExecCtx::Get()->IsReadyToFinish(),
                               lock->time_to_execute_final_list));
 
-  if (grpc_core::IsCombinerOffloadToEventEngineEnabled()) {
-    // offload only if both (1) the combiner is contended and has more than one
-    // closure to execute, and (2) the current execution context needs to finish
-    // as soon as possible
-    if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish()) {
-      // this execution context wants to move on: schedule remaining work to be
-      // picked up on the executor
-      queue_offload(lock);
-      return true;
-    }
-  } else {
-    // TODO(ctiller): delete this when the combiner_offload_to_event_engine
-    // experiment is removed.
-
-    // offload only if all the following conditions are true:
-    // 1. the combiner is contended and has more than one closure to execute
-    // 2. the current execution context needs to finish as soon as possible
-    // 3. the current thread is not a worker for any background poller
-    // 4. the DEFAULT executor is threaded
-    if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish() &&
-        !grpc_iomgr_platform_is_any_background_poller_thread() &&
-        grpc_core::Executor::IsThreadedDefault()) {
-      // this execution context wants to move on: schedule remaining work to be
-      // picked up on the executor
-      queue_offload(lock);
-      return true;
-    }
+  // offload only if both (1) the combiner is contended and has more than one
+  // closure to execute, and (2) the current execution context needs to finish
+  // as soon as possible
+  if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish()) {
+    // this execution context wants to move on: schedule remaining work to be
+    // picked up on the executor
+    queue_offload(lock);
+    return true;
   }
 
   if (!lock->time_to_execute_final_list ||

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -17,6 +17,7 @@
 
 #include <atomic>
 #include <memory>
+#include <utility>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
@@ -69,6 +70,12 @@ class EventEngineEndpointWrapper {
   explicit EventEngineEndpointWrapper(
       std::unique_ptr<EventEngine::Endpoint> endpoint);
 
+  EventEngine::Endpoint* endpoint() { return endpoint_.get(); }
+
+  std::unique_ptr<EventEngine::Endpoint> ReleaseEndpoint() {
+    return std::move(endpoint_);
+  }
+
   int Fd() {
     grpc_core::MutexLock lock(&mu_);
     return fd_;
@@ -428,6 +435,30 @@ bool grpc_is_event_engine_endpoint(grpc_endpoint* ep) {
   return ep->vtable == &grpc_event_engine_endpoint_vtable;
 }
 
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  return eeep->wrapper->endpoint();
+}
+
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep) {
+  if (!grpc_is_event_engine_endpoint(ep)) {
+    return nullptr;
+  }
+  auto* eeep =
+      reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
+          ep);
+  auto endpoint = eeep->wrapper->ReleaseEndpoint();
+  delete eeep->wrapper;
+  return endpoint;
+}
+
 void grpc_event_engine_endpoint_destroy_and_release_fd(
     grpc_endpoint* ep, int* fd, grpc_closure* on_release_fd) {
   auto* eeep =

data/src/core/lib/iomgr/event_engine_shims/endpoint.h

@@ -15,6 +15,8 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_EVENT_ENGINE_SHIMS_ENDPOINT_H
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/iomgr/endpoint.h"
@@ -31,6 +33,20 @@ grpc_endpoint* grpc_event_engine_endpoint_create(
 /// Returns true if the passed endpoint is an event engine shim endpoint.
 bool grpc_is_event_engine_endpoint(grpc_endpoint* ep);
 
+/// Returns the wrapped event engine endpoint if the given grpc_endpoint is an
+/// event engine shim endpoint. Otherwise it returns nullptr.
+EventEngine::Endpoint* grpc_get_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep);
+
+/// Transfers ownership of the wrapped event engine endpoint if the given
+/// grpc_endpoint is an event engine shim endpoint. Otherwise it returns
+/// nullptr. If the passed ep wraps an event_engine endpoint, then after this
+/// call, the memory location holding by the passed ep is free'ed.
+/// Its safe to call this function only when there are no pending reads/writes
+/// on the endpoint.
+std::unique_ptr<EventEngine::Endpoint> grpc_take_wrapped_event_engine_endpoint(
+    grpc_endpoint* ep);
+
 /// Destroys the passed in event engine shim endpoint and schedules the
 /// asynchronous execution of the on_release_fd callback. The int pointer fd is
 /// set to the underlying endpoint's file descriptor.

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -336,6 +336,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
                   addr->len);
   } while (err < 0 && errno == EINTR);
+  int connect_errno = (err < 0) ? errno : 0;
 
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   if (!addr_uri.ok()) {
@@ -347,7 +348,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   std::string name = absl::StrCat("tcp-client:", addr_uri.value());
   grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
   int64_t connection_id = 0;
-  if (errno == EWOULDBLOCK || errno == EINPROGRESS) {
+  if (connect_errno == EWOULDBLOCK || connect_errno == EINPROGRESS) {
     // Connection is still in progress.
     connection_id = g_connection_id.fetch_add(1, std::memory_order_acq_rel);
   }
@@ -359,10 +360,10 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
     return 0;
   }
-  if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
+  if (connect_errno != EWOULDBLOCK && connect_errno != EINPROGRESS) {
     // Connection already failed. Return 0 to discourage any cancellation
     // attempts.
-    grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
+    grpc_error_handle error = GRPC_OS_ERROR(connect_errno, "connect");
     error = grpc_error_set_str(
         error, grpc_core::StatusStrProperty::kTargetAddress, addr_uri.value());
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");

data/src/core/lib/load_balancing/lb_policy.h

@@ -346,7 +346,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   struct UpdateArgs {
     /// A list of endpoints, each with one or more address, or an error
     /// indicating a failure to obtain the list of addresses.
-    absl::StatusOr<EndpointAddressesList> addresses;
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses;
     /// The LB policy config.
     RefCountedPtr<Config> config;
     /// A human-readable note providing context about the name resolution that