grpc 1.78.1 → 1.80.0

data/src/core/lib/iomgr/tcp_server_utils_posix.h

@@ -90,9 +90,6 @@ struct grpc_tcp_server {
   // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting{nullptr, nullptr};
 
-  // List of closures passed to shutdown_ending_add().
-  grpc_closure_list shutdown_ending{nullptr, nullptr};
-
   // shutdown callback
   grpc_closure* shutdown_complete = nullptr;
 

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

@@ -123,9 +123,6 @@ struct grpc_tcp_server {
   // List of closures passed to shutdown_starting_add().
   grpc_closure_list shutdown_starting;
 
-  // List of closures passed to shutdown_ending_add().
-  grpc_closure_list shutdown_ending;
-
   // shutdown callback
   grpc_closure* shutdown_complete;
 
@@ -191,8 +188,6 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->tail = NULL;
   s->shutdown_starting.head = NULL;
   s->shutdown_starting.tail = NULL;
-  s->shutdown_ending.head = NULL;
-  s->shutdown_ending.tail = NULL;
   s->shutdown_complete = shutdown_complete;
   new (&s->ee_listener) std::unique_ptr<EventEngine::Listener>(nullptr);
   *server = s;
@@ -224,7 +219,6 @@ static void finish_shutdown_locked(grpc_tcp_server* s) {
                             absl::OkStatus());
   }
 
-  grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
   grpc_core::ExecCtx::Run(
       DEBUG_LOCATION,
       GRPC_CLOSURE_CREATE(destroy_server, s, grpc_schedule_on_exec_ctx),
@@ -244,14 +238,6 @@ static void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
   gpr_mu_unlock(&s->mu);
 }
 
-static void tcp_server_shutdown_ending_add(grpc_tcp_server* s,
-                                           grpc_closure* shutdown_ending) {
-  gpr_mu_lock(&s->mu);
-  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
-                           absl::OkStatus());
-  gpr_mu_unlock(&s->mu);
-}
-
 static void tcp_server_destroy(grpc_tcp_server* s) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
@@ -651,19 +637,12 @@ static int tcp_pre_allocated_fd(grpc_tcp_server* /* s */) { return -1; }
 static void tcp_set_pre_allocated_fd(grpc_tcp_server* /* s */, int /* fd */) {}
 
 grpc_tcp_server_vtable grpc_windows_tcp_server_vtable = {
-    tcp_server_create,
-    tcp_server_start,
-    tcp_server_add_port,
-    tcp_server_create_fd_handler,
-    tcp_server_port_fd_count,
-    tcp_server_port_fd,
-    tcp_server_ref,
-    tcp_server_shutdown_starting_add,
-    tcp_server_shutdown_ending_add,
-    tcp_server_unref,
-    tcp_server_shutdown_listeners,
-    tcp_pre_allocated_fd,
-    tcp_set_pre_allocated_fd};
+    tcp_server_create,        tcp_server_start,
+    tcp_server_add_port,      tcp_server_create_fd_handler,
+    tcp_server_port_fd_count, tcp_server_port_fd,
+    tcp_server_ref,           tcp_server_shutdown_starting_add,
+    tcp_server_unref,         tcp_server_shutdown_listeners,
+    tcp_pre_allocated_fd,     tcp_set_pre_allocated_fd};
 
 // ---- EventEngine shim ------------------------------------------------------
 
@@ -727,8 +706,6 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   s->tail = nullptr;
   s->shutdown_starting.head = nullptr;
   s->shutdown_starting.tail = nullptr;
-  s->shutdown_ending.head = nullptr;
-  s->shutdown_ending.tail = nullptr;
   s->shutdown_complete = grpc_core::NewClosure([](absl::Status) {
     grpc_core::Crash("iomgr shutdown_complete callback should be unused");
   });
@@ -790,7 +767,6 @@ static void event_engine_unref(grpc_tcp_server* s) {
     gpr_mu_unlock(&s->mu);
     gpr_mu_destroy(&s->mu);
     std::destroy_at(&s->ee_listener);
-    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &s->shutdown_ending);
     gpr_free(s);
   }
 }
@@ -803,29 +779,14 @@ static void event_engine_shutdown_starting_add(
   gpr_mu_unlock(&s->mu);
 }
 
-static void event_engine_shutdown_ending_add(grpc_tcp_server* s,
-                                             grpc_closure* shutdown_ending) {
-  gpr_mu_lock(&s->mu);
-  grpc_closure_list_append(&s->shutdown_ending, shutdown_ending,
-                           absl::OkStatus());
-  gpr_mu_unlock(&s->mu);
-}
-
 }  // namespace
 
 grpc_tcp_server_vtable grpc_windows_event_engine_tcp_server_vtable = {
-    event_engine_create,
-    event_engine_start,
-    event_engine_add_port,
-    event_engine_create_fd_handler,
-    event_engine_port_fd_count,
-    event_engine_port_fd,
-    event_engine_ref,
-    event_engine_shutdown_starting_add,
-    event_engine_shutdown_ending_add,
-    event_engine_unref,
-    event_engine_shutdown_listeners,
-    tcp_pre_allocated_fd,
-    tcp_set_pre_allocated_fd};
+    event_engine_create,        event_engine_start,
+    event_engine_add_port,      event_engine_create_fd_handler,
+    event_engine_port_fd_count, event_engine_port_fd,
+    event_engine_ref,           event_engine_shutdown_starting_add,
+    event_engine_unref,         event_engine_shutdown_listeners,
+    tcp_pre_allocated_fd,       tcp_set_pre_allocated_fd};
 
 #endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/promise/all_ok.h

@@ -17,17 +17,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <tuple>
-#include <variant>
+#include <type_traits>
+#include <utility>
 
 #include "src/core/lib/promise/detail/join_state.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
-#include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
 
 namespace grpc_core {
 // AllOk promise combinator.
@@ -93,12 +90,18 @@ struct AllOkTraits {
 template <typename Result, typename... Promises>
 class AllOk {
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit AllOk(Promises... promises)
-      : state_(std::move(promises)...) {}
+  template <typename... Args>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit AllOk(Args&&... args)
+      : state_(std::forward<Args>(args)...) {}
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto operator()() {
     return state_.PollOnce();
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_ALL_OK, promise_proto, arena);
+  }
+
  private:
   JoinState<AllOkTraits<Result>, Promises...> state_;
 };
@@ -109,18 +112,20 @@ class AllOk {
 // If any fail, cancel the rest and return the failure.
 // If all succeed, return Ok.
 template <typename Result, typename... Promises>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AllOk(Promises... promises) {
-  return promise_detail::AllOk<Result, Promises...>(std::move(promises)...);
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AllOk(Promises&&... promises) {
+  return promise_detail::AllOk<Result, std::decay_t<Promises>...>(
+      std::forward<Promises>(promises)...);
 }
 
 // Construct a promise for each element of the set, then run them all.
 // If any fail, cancel the rest and return the failure.
 // If all succeed, return Ok.
 template <typename Result, typename Iter, typename FactoryFn>
-inline auto AllOkIter(Iter begin, Iter end, FactoryFn factory_fn) {
+inline auto AllOkIter(Iter begin, Iter end, FactoryFn&& factory_fn) {
   using Factory =
-      promise_detail::RepeatedPromiseFactory<decltype(*begin), FactoryFn>;
-  Factory factory(std::move(factory_fn));
+      promise_detail::RepeatedPromiseFactory<decltype(*begin),
+                                             std::decay_t<FactoryFn>>;
+  Factory factory(std::forward<FactoryFn>(factory_fn));
   using Promise = typename Factory::Promise;
   std::vector<Promise> promises;
   std::vector<bool> done;

data/src/core/lib/promise/cancel_callback.h

@@ -28,8 +28,8 @@ namespace cancel_callback_detail {
 template <typename Fn>
 class Handler {
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Handler(Fn fn)
-      : fn_(std::move(fn)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Handler(Fn&& fn)
+      : fn_(std::forward<Fn>(fn)) {}
   Handler(const Handler&) = delete;
   Handler& operator=(const Handler&) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Handler() {
@@ -69,12 +69,12 @@ class Handler {
 // completion.
 // Returns a promise with the same result type as main_fn.
 template <typename MainFn, typename CancelFn>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto OnCancel(MainFn main_fn,
-                                                          CancelFn cancel_fn) {
-  return [on_cancel =
-              cancel_callback_detail::Handler<CancelFn>(std::move(cancel_fn)),
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto OnCancel(
+    MainFn&& main_fn, CancelFn&& cancel_fn) {
+  return [on_cancel = cancel_callback_detail::Handler<CancelFn>(
+              std::forward<CancelFn>(cancel_fn)),
           main_fn = promise_detail::PromiseLike<MainFn>(
-              std::move(main_fn))]() mutable {
+              std::forward<MainFn>(main_fn))]() mutable {
     auto r = main_fn();
     if (r.ready()) {
       on_cancel.Done();
@@ -88,13 +88,12 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto OnCancel(MainFn main_fn,
 // is called.
 template <typename MainFn, typename CancelFn>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto OnCancelFactory(
-    MainFn main_fn, CancelFn cancel_fn) {
-  return [on_cancel =
-              cancel_callback_detail::Handler<CancelFn>(std::move(cancel_fn)),
-          main_fn = std::move(main_fn)]() mutable {
-    auto r = main_fn();
+    MainFn&& main_fn, CancelFn&& cancel_fn) {
+  return [on_cancel = cancel_callback_detail::Handler<CancelFn>(
+              std::forward<CancelFn>(cancel_fn)),
+          main_fn = std::forward<MainFn>(main_fn)]() mutable {
     on_cancel.Done();
-    return r;
+    return main_fn();
   };
 };