grpc 1.48.0 → 1.50.0

data/src/core/lib/http/httpcli.cc

@@ -25,7 +25,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/functional/bind_front.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -165,7 +164,8 @@ HttpRequest::HttpRequest(
       channel_args_(CoreConfiguration::Get()
                         .channel_args_preconditioning()
                         .PreconditionChannelArgs(channel_args)
-                        .ToC()),
+                        .ToC()
+                        .release()),
       channel_creds_(std::move(channel_creds)),
       on_done_(on_done),
       resource_quota_(ResourceQuotaFromChannelArgs(channel_args_)),
@@ -209,9 +209,10 @@ void HttpRequest::Start() {
     return;
   }
   Ref().release();  // ref held by pending DNS resolution
-  dns_request_handle_ = GetDNSResolver()->ResolveName(
-      uri_.authority(), uri_.scheme(), pollset_set_,
-      absl::bind_front(&HttpRequest::OnResolved, this));
+  dns_request_handle_ = GetDNSResolver()->LookupHostname(
+      absl::bind_front(&HttpRequest::OnResolved, this), uri_.authority(),
+      uri_.scheme(), kDefaultDNSRequestTimeout, pollset_set_,
+      /*name_server=*/"");
 }
 
 void HttpRequest::Orphan() {
@@ -312,7 +313,6 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
     return;
   }
   // Handshake completed, so we own fields in args
-  grpc_channel_args_destroy(args->args);
   grpc_slice_buffer_destroy_internal(args->read_buffer);
   gpr_free(args->read_buffer);
   req->ep_ = args->endpoint;
@@ -327,11 +327,10 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
 
 void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
   // Create the security connector using the credentials and target name.
-  grpc_channel_args* new_args_from_connector = nullptr;
+  ChannelArgs args = ChannelArgs::FromC(channel_args_);
   RefCountedPtr<grpc_channel_security_connector> sc =
       channel_creds_->create_security_connector(
-          nullptr /*call_creds*/, uri_.authority().c_str(), channel_args_,
-          &new_args_from_connector);
+          nullptr /*call_creds*/, uri_.authority().c_str(), &args);
   if (sc == nullptr) {
     Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "failed to create security connector", &overall_error_, 1));
@@ -343,30 +342,19 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
         "Failed to extract URI from address", &overall_error_, 1));
     return;
   }
-  absl::InlinedVector<grpc_arg, 2> args_to_add = {
-      grpc_security_connector_to_arg(sc.get()),
-      grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS),
-          const_cast<char*>(address.value().c_str())),
-  };
-  const grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
-      new_args_from_connector != nullptr ? new_args_from_connector
-                                         : channel_args_,
-      args_to_add.data(), args_to_add.size());
-  grpc_channel_args_destroy(new_args_from_connector);
+  args = args.SetObject(std::move(sc))
+             .Set(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS, address.value());
   // Start the handshake
   handshake_mgr_ = MakeRefCounted<HandshakeManager>();
   CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      HANDSHAKER_CLIENT, new_args, pollset_set_, handshake_mgr_.get());
+      HANDSHAKER_CLIENT, args, pollset_set_, handshake_mgr_.get());
   Ref().release();  // ref held by pending handshake
   grpc_endpoint* ep = ep_;
   ep_ = nullptr;
   own_endpoint_ = false;
-  handshake_mgr_->DoHandshake(ep, new_args, deadline_,
+  handshake_mgr_->DoHandshake(ep, args, deadline_,
                               /*acceptor=*/nullptr, OnHandshakeDone,
                               /*user_data=*/this);
-  sc.reset(DEBUG_LOCATION, "httpcli");
-  grpc_channel_args_destroy(new_args);
 }
 
 void HttpRequest::NextAddress(grpc_error_handle error) {

data/src/core/lib/http/httpcli_security_connector.cc

@@ -20,9 +20,12 @@
 
 #include <string.h>
 
+#include <string>
+
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
@@ -41,7 +44,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/promise/arena_promise.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
@@ -83,7 +85,7 @@ class grpc_httpcli_ssl_channel_security_connector final
         &options, &handshaker_factory_);
   }
 
-  void add_handshakers(const grpc_channel_args* args,
+  void add_handshakers(const ChannelArgs& args,
                        grpc_pollset_set* /*interested_parties*/,
                        HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
@@ -104,6 +106,7 @@ class grpc_httpcli_ssl_channel_security_connector final
   }
 
   void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
+                  const ChannelArgs& /*args*/,
                   RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error_handle error = GRPC_ERROR_NONE;
@@ -167,8 +170,7 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
  public:
   RefCountedPtr<grpc_channel_security_connector> create_security_connector(
       RefCountedPtr<grpc_call_credentials> /*call_creds*/, const char* target,
-      const grpc_channel_args* args,
-      grpc_channel_args** /*new_args*/) override {
+      ChannelArgs* args) override {
     const char* pem_root_certs = DefaultSslRootStore::GetPemRootCerts();
     const tsi_ssl_root_certs_store* root_store =
         DefaultSslRootStore::GetRootStore();
@@ -176,13 +178,11 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
       gpr_log(GPR_ERROR, "Could not get default pem root certs.");
       return nullptr;
     }
-    const char* ssl_host_override =
-        grpc_channel_args_find_string(args, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
-    if (ssl_host_override != nullptr) {
-      target = ssl_host_override;
-    }
-    return httpcli_ssl_channel_security_connector_create(pem_root_certs,
-                                                         root_store, target);
+    absl::optional<std::string> target_string =
+        args->GetOwnedString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)
+            .value_or(target);
+    return httpcli_ssl_channel_security_connector_create(
+        pem_root_certs, root_store, target_string->c_str());
   }
 
   RefCountedPtr<grpc_channel_credentials> duplicate_without_call_credentials()

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

@@ -25,7 +25,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/profiling/timers.h"
 
 namespace grpc_core {
 
@@ -38,11 +37,7 @@ constexpr intptr_t kErrorBit = 1;
 
 grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
-#else
-    return reinterpret_cast<grpc_error_handle>(cancel_state & ~kErrorBit);
-#endif
   }
   return GRPC_ERROR_NONE;
 }
@@ -60,12 +55,7 @@ CallCombiner::CallCombiner() {
 
 CallCombiner::~CallCombiner() {
   if (cancel_state_ & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     internal::StatusFreeHeapPtr(cancel_state_ & ~kErrorBit);
-#else
-    GRPC_ERROR_UNREF(reinterpret_cast<grpc_error_handle>(
-        cancel_state_ & ~static_cast<gpr_atm>(kErrorBit)));
-#endif
   }
 }
 
@@ -122,7 +112,6 @@ void CallCombiner::ScheduleClosure(grpc_closure* closure,
 
 void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
                          DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Start", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO,
             "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
@@ -136,10 +125,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
-  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS();
   if (prev_size == 0) {
-    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("call_combiner_initiate", 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
       gpr_log(GPR_INFO, "  EXECUTING IMMEDIATELY");
     }
@@ -150,18 +136,13 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
       gpr_log(GPR_INFO, "  QUEUING");
     }
     // Queue was not empty, so add closure to queue.
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     closure->error_data.error = internal::StatusAllocHeapPtr(error);
-#else
-    closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
     queue_.Push(
         reinterpret_cast<MultiProducerSingleConsumerQueue::Node*>(closure));
   }
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Stop", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO, "==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
             this DEBUG_FMT_ARGS, reason);
@@ -189,13 +170,8 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
         }
         continue;
       }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       grpc_error_handle error =
           internal::StatusMoveFromHeapPtr(closure->error_data.error);
-#else
-      grpc_error_handle error =
-          reinterpret_cast<grpc_error_handle>(closure->error_data.error);
-#endif
       closure->error_data.error = 0;
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%p error=%s",
@@ -210,7 +186,6 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
 }
 
 void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
-  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL();
   while (true) {
     // Decode original state.
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
@@ -253,22 +228,13 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 }
 
 void CallCombiner::Cancel(grpc_error_handle error) {
-  GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
   gpr_atm new_state = kErrorBit | status_ptr;
-#else
-  gpr_atm new_state = kErrorBit | reinterpret_cast<gpr_atm>(error);
-#endif
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     if (!GRPC_ERROR_IS_NONE(original_error)) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       internal::StatusFreeHeapPtr(status_ptr);
-#else
-      GRPC_ERROR_UNREF(error);
-#endif
       break;
     }
     if (gpr_atm_full_cas(&cancel_state_, original_state, new_state)) {

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

@@ -31,7 +31,6 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
 struct grpc_closure;
 typedef struct grpc_closure grpc_closure;
@@ -199,11 +198,7 @@ inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
     GRPC_ERROR_UNREF(error);
     return false;
   }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   closure->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
-#else
-  closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
   return grpc_closure_list_append(closure_list, closure);
 }
 
@@ -212,13 +207,8 @@ inline void grpc_closure_list_fail_all(grpc_closure_list* list,
                                        grpc_error_handle forced_failure) {
   for (grpc_closure* c = list->head; c != nullptr; c = c->next_data.next) {
     if (c->error_data.error == 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       c->error_data.error =
           grpc_core::internal::StatusAllocHeapPtr(forced_failure);
-#else
-      c->error_data.error =
-          reinterpret_cast<intptr_t>(GRPC_ERROR_REF(forced_failure));
-#endif
     }
   }
   GRPC_ERROR_UNREF(forced_failure);

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

@@ -149,11 +149,7 @@ static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
   }
   GPR_ASSERT(last & STATE_UNORPHANED);  // ensure lock has not been destroyed
   assert(cl->cb);
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   cl->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
-#else
-  cl->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
   lock->queue.Push(cl->next_data.mpscq_node.get());
 }
 
@@ -228,18 +224,10 @@ bool grpc_combiner_continue_exec_ctx() {
 #ifndef NDEBUG
     cl->scheduled = false;
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     grpc_error_handle cl_err =
         grpc_core::internal::StatusMoveFromHeapPtr(cl->error_data.error);
     cl->error_data.error = 0;
     cl->cb(cl->cb_arg, std::move(cl_err));
-#else
-    grpc_error_handle cl_err =
-        reinterpret_cast<grpc_error_handle>(cl->error_data.error);
-    cl->error_data.error = 0;
-    cl->cb(cl->cb_arg, cl_err);
-    GRPC_ERROR_UNREF(cl_err);
-#endif
   } else {
     grpc_closure* c = lock->final_list.head;
     GPR_ASSERT(c != nullptr);
@@ -252,18 +240,10 @@ bool grpc_combiner_continue_exec_ctx() {
 #ifndef NDEBUG
       c->scheduled = false;
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       grpc_error_handle error =
           grpc_core::internal::StatusMoveFromHeapPtr(c->error_data.error);
       c->error_data.error = 0;
       c->cb(c->cb_arg, std::move(error));
-#else
-      grpc_error_handle error =
-          reinterpret_cast<grpc_error_handle>(c->error_data.error);
-      c->error_data.error = 0;
-      c->cb(c->cb_arg, error);
-      GRPC_ERROR_UNREF(error);
-#endif
       c = next;
     }
   }

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

@@ -35,6 +35,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
@@ -60,16 +61,20 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   std::string final_name = absl::StrCat(name, ":client");
-  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
-                                          .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args)
-                                          .ToC();
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
-                             new_args, "socketpair-server");
+  auto new_args = grpc_core::CoreConfiguration::Get()
+                      .channel_args_preconditioning()
+                      .PreconditionChannelArgs(args);
+  p.client = grpc_tcp_create(
+      grpc_fd_create(sv[1], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-server");
   final_name = absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
-                             new_args, "socketpair-client");
-  grpc_channel_args_destroy(new_args);
+  p.server = grpc_tcp_create(
+      grpc_fd_create(sv[0], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-client");
   return p;
 }
 

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

@@ -77,9 +77,9 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                             channel_args, "endpoint:server");
+                             "endpoint:server");
   p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                             channel_args, "endpoint:client");
+                             "endpoint:client");
   return p;
 }