grpc 1.28.0 → 1.37.0

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

@@ -41,13 +41,12 @@ typedef struct grpc_httpcli_context {
   grpc_pollset_set* pollset_set;
 } grpc_httpcli_context;
 
-typedef struct {
+struct grpc_httpcli_handshaker {
   const char* default_port;
   void (*handshake)(void* arg, grpc_endpoint* endpoint, const char* host,
                     grpc_millis deadline,
                     void (*on_done)(void* arg, grpc_endpoint* endpoint));
-} grpc_httpcli_handshaker;
-
+};
 extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
 extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
 
@@ -84,8 +83,7 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_polling_entity* pollent,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_complete,
-                      grpc_httpcli_response* response);
+                      grpc_closure* on_done, grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
@@ -106,7 +104,7 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        grpc_resource_quota* resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_complete,
+                       grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response);
 
 /* override functions return 1 if they handled the request, 0 otherwise */

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

@@ -22,6 +22,9 @@
 
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -30,7 +33,6 @@
 #include "src/core/lib/channel/handshaker_registry.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/string_view.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
@@ -41,7 +43,7 @@
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
-  grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
+  explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
             /*url_scheme=*/nullptr,
             /*channel_creds=*/nullptr,
@@ -94,11 +96,10 @@ class grpc_httpcli_ssl_channel_security_connector final
     /* Check the peer name. */
     if (secure_peer_name_ != nullptr &&
         !tsi_ssl_peer_matches_name(&peer, secure_peer_name_)) {
-      char* msg;
-      gpr_asprintf(&msg, "Peer name %s is not in peer certificate",
-                   secure_peer_name_);
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
+      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("Peer name ", secure_peer_name_,
+                       " is not in peer certificate")
+              .c_str());
     }
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
@@ -111,7 +112,7 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(grpc_core::StringView /*host*/,
+  bool check_call_host(absl::string_view /*host*/,
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
@@ -154,12 +155,11 @@ httpcli_ssl_channel_security_connector_create(
 
 /* handshaker */
 
-typedef struct {
+struct on_done_closure {
   void (*func)(void* arg, grpc_endpoint* endpoint);
   void* arg;
   grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
-} on_done_closure;
-
+};
 static void on_handshake_done(void* arg, grpc_error* error) {
   auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   on_done_closure* c = static_cast<on_done_closure*>(args->user_data);
@@ -203,8 +203,8 @@ static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
   grpc_channel_args args = {1, &channel_arg};
   c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
   grpc_core::HandshakerRegistry::AddHandshakers(
-      grpc_core::HANDSHAKER_CLIENT, &args, /*interested_parties=*/nullptr,
-      c->handshake_mgr.get());
+      grpc_core::HANDSHAKER_CLIENT, &args,
+      /*interested_parties=*/nullptr, c->handshake_mgr.get());
   c->handshake_mgr->DoHandshake(tcp, /*channel_args=*/nullptr, deadline,
                                 /*acceptor=*/nullptr, on_handshake_done,
                                 /*user_data=*/c);

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

@@ -42,36 +42,48 @@ static grpc_error* handle_response_line(grpc_http_parser* parser) {
   uint8_t* cur = beg;
   uint8_t* end = beg + parser->cur_line_length;
 
-  if (cur == end || *cur++ != 'H')
+  if (cur == end || *cur++ != 'H') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'H'");
-  if (cur == end || *cur++ != 'T')
+  }
+  if (cur == end || *cur++ != 'T') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
-  if (cur == end || *cur++ != 'T')
+  }
+  if (cur == end || *cur++ != 'T') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
-  if (cur == end || *cur++ != 'P')
+  }
+  if (cur == end || *cur++ != 'P') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'P'");
-  if (cur == end || *cur++ != '/')
+  }
+  if (cur == end || *cur++ != '/') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '/'");
-  if (cur == end || *cur++ != '1')
+  }
+  if (cur == end || *cur++ != '1') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '1'");
-  if (cur == end || *cur++ != '.')
+  }
+  if (cur == end || *cur++ != '.') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '.'");
+  }
   if (cur == end || *cur < '0' || *cur++ > '1') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Expected HTTP/1.0 or HTTP/1.1");
   }
-  if (cur == end || *cur++ != ' ')
+  if (cur == end || *cur++ != ' ') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected ' '");
-  if (cur == end || *cur < '1' || *cur++ > '9')
+  }
+  if (cur == end || *cur < '1' || *cur++ > '9') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
-  if (cur == end || *cur < '0' || *cur++ > '9')
+  }
+  if (cur == end || *cur < '0' || *cur++ > '9') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
-  if (cur == end || *cur < '0' || *cur++ > '9')
+  }
+  if (cur == end || *cur < '0' || *cur++ > '9') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected status code");
+  }
   parser->http.response->status =
       (cur[-3] - '0') * 100 + (cur[-2] - '0') * 10 + (cur[-1] - '0');
-  if (cur == end || *cur++ != ' ')
+  if (cur == end || *cur++ != ' ') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected ' '");
+  }
 
   /* we don't really care about the status code message */
 
@@ -85,36 +97,44 @@ static grpc_error* handle_request_line(grpc_http_parser* parser) {
   uint8_t vers_major = 0;
   uint8_t vers_minor = 0;
 
-  while (cur != end && *cur++ != ' ')
-    ;
-  if (cur == end)
+  while (cur != end && *cur++ != ' ') {
+  }
+  if (cur == end) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "No method on HTTP request line");
+  }
   parser->http.request->method =
       buf2str(beg, static_cast<size_t>(cur - beg - 1));
 
   beg = cur;
-  while (cur != end && *cur++ != ' ')
-    ;
-  if (cur == end)
+  while (cur != end && *cur++ != ' ') {
+  }
+  if (cur == end) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No path on HTTP request line");
+  }
   parser->http.request->path = buf2str(beg, static_cast<size_t>(cur - beg - 1));
 
-  if (cur == end || *cur++ != 'H')
+  if (cur == end || *cur++ != 'H') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'H'");
-  if (cur == end || *cur++ != 'T')
+  }
+  if (cur == end || *cur++ != 'T') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
-  if (cur == end || *cur++ != 'T')
+  }
+  if (cur == end || *cur++ != 'T') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'T'");
-  if (cur == end || *cur++ != 'P')
+  }
+  if (cur == end || *cur++ != 'P') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'P'");
-  if (cur == end || *cur++ != '/')
+  }
+  if (cur == end || *cur++ != '/') {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected '/'");
+  }
   vers_major = static_cast<uint8_t>(*cur++ - '1' + 1);
   ++cur;
-  if (cur == end)
+  if (cur == end) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "End of line in HTTP version string");
+  }
   vers_minor = static_cast<uint8_t>(*cur++ - '1' + 1);
 
   if (vers_major == 1) {
@@ -261,8 +281,7 @@ static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) {
 
   if (*body_length == parser->body_capacity) {
     parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
-    *body =
-        static_cast<char*>(gpr_realloc((void*)*body, parser->body_capacity));
+    *body = static_cast<char*>(gpr_realloc(*body, parser->body_capacity));
   }
   (*body)[*body_length] = static_cast<char>(byte);
   (*body_length)++;
@@ -300,9 +319,10 @@ static grpc_error* addbyte(grpc_http_parser* parser, uint8_t byte,
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace))
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace)) {
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
                   GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
+        }
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "HTTP header max line length exceeded");
       }

data/src/core/lib/http/parser.h

@@ -79,7 +79,7 @@ typedef struct grpc_http_response {
   char* body = nullptr;
 } grpc_http_response;
 
-typedef struct {
+struct grpc_http_parser {
   grpc_http_parser_state state;
   grpc_http_type type;
 
@@ -94,8 +94,7 @@ typedef struct {
   uint8_t cur_line[GRPC_HTTP_PARSER_MAX_HEADER_LENGTH];
   size_t cur_line_length;
   size_t cur_line_end_length;
-} grpc_http_parser;
-
+};
 void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
                            void* request_or_response);
 void grpc_http_parser_destroy(grpc_http_parser* parser);

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

@@ -21,12 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 
@@ -34,52 +35,52 @@ namespace grpc_core {
 
 struct ConnectionMetrics {
   /* Delivery rate in Bytes/s. */
-  Optional<uint64_t> delivery_rate;
+  absl::optional<uint64_t> delivery_rate;
   /* If the delivery rate is limited by the application, this is set to true. */
-  Optional<bool> is_delivery_rate_app_limited;
+  absl::optional<bool> is_delivery_rate_app_limited;
   /* Total packets retransmitted. */
-  Optional<uint32_t> packet_retx;
+  absl::optional<uint32_t> packet_retx;
   /* Total packets retransmitted spuriously. This metric is smaller than or
   equal to packet_retx. */
-  Optional<uint32_t> packet_spurious_retx;
+  absl::optional<uint32_t> packet_spurious_retx;
   /* Total packets sent. */
-  Optional<uint32_t> packet_sent;
+  absl::optional<uint32_t> packet_sent;
   /* Total packets delivered. */
-  Optional<uint32_t> packet_delivered;
+  absl::optional<uint32_t> packet_delivered;
   /* Total packets delivered with ECE marked. This metric is smaller than or
   equal to packet_delivered. */
-  Optional<uint32_t> packet_delivered_ce;
+  absl::optional<uint32_t> packet_delivered_ce;
   /* Total bytes lost so far. */
-  Optional<uint64_t> data_retx;
+  absl::optional<uint64_t> data_retx;
   /* Total bytes sent so far. */
-  Optional<uint64_t> data_sent;
+  absl::optional<uint64_t> data_sent;
   /* Total bytes in write queue but not sent. */
-  Optional<uint64_t> data_notsent;
+  absl::optional<uint64_t> data_notsent;
   /* Pacing rate of the connection in Bps */
-  Optional<uint64_t> pacing_rate;
+  absl::optional<uint64_t> pacing_rate;
   /* Minimum RTT observed in usec. */
-  Optional<uint32_t> min_rtt;
+  absl::optional<uint32_t> min_rtt;
   /* Smoothed RTT in usec */
-  Optional<uint32_t> srtt;
+  absl::optional<uint32_t> srtt;
   /* Send congestion window. */
-  Optional<uint32_t> congestion_window;
+  absl::optional<uint32_t> congestion_window;
   /* Slow start threshold in packets. */
-  Optional<uint32_t> snd_ssthresh;
+  absl::optional<uint32_t> snd_ssthresh;
   /* Maximum degree of reordering (i.e., maximum number of packets reodered)
    on the connection. */
-  Optional<uint32_t> reordering;
+  absl::optional<uint32_t> reordering;
   /* Represents the number of recurring retransmissions of the first sequence
   that is not acknowledged yet. */
-  Optional<uint8_t> recurring_retrans;
+  absl::optional<uint8_t> recurring_retrans;
   /* The cumulative time (in usec) that the transport protocol was busy
    sending data. */
-  Optional<uint64_t> busy_usec;
+  absl::optional<uint64_t> busy_usec;
   /* The cumulative time (in usec) that the transport protocol was limited by
    the receive window size. */
-  Optional<uint64_t> rwnd_limited_usec;
+  absl::optional<uint64_t> rwnd_limited_usec;
   /* The cumulative time (in usec) that the transport protocol was limited by
    the send buffer size. */
-  Optional<uint64_t> sndbuf_limited_usec;
+  absl::optional<uint64_t> sndbuf_limited_usec;
 };
 
 struct Timestamp {
@@ -145,7 +146,7 @@ class TracedBuffer {
 #else  /* GRPC_LINUX_ERRQUEUE */
 class TracedBuffer {
  public:
-  /* Dummy shutdown function */
+  /* Phony shutdown function */
   static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error* shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);

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

@@ -34,13 +34,14 @@ namespace {
 
 grpc_error* DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & 1) {
-    return (grpc_error*)(cancel_state & ~static_cast<gpr_atm>(1));
+    return reinterpret_cast<grpc_error*>(cancel_state &
+                                         ~static_cast<gpr_atm>(1));
   }
   return GRPC_ERROR_NONE;
 }
 
 gpr_atm EncodeCancelStateError(grpc_error* error) {
-  return static_cast<gpr_atm>(1) | (gpr_atm)error;
+  return static_cast<gpr_atm>(1) | reinterpret_cast<gpr_atm>(error);
 }
 
 }  // namespace
@@ -203,7 +204,8 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
       ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(original_error));
       break;
     } else {
-      if (gpr_atm_full_cas(&cancel_state_, original_state, (gpr_atm)closure)) {
+      if (gpr_atm_full_cas(&cancel_state_, original_state,
+                           reinterpret_cast<gpr_atm>(closure))) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
           gpr_log(GPR_INFO, "call_combiner=%p: setting notify_on_cancel=%p",
                   this, closure);
@@ -212,7 +214,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
         // closure with GRPC_ERROR_NONE.  This allows callers to clean
         // up any resources they may be holding for the callback.
         if (original_state != 0) {
-          closure = (grpc_closure*)original_state;
+          closure = reinterpret_cast<grpc_closure*>(original_state);
           if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
             gpr_log(GPR_INFO,
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
@@ -239,7 +241,8 @@ void CallCombiner::Cancel(grpc_error* error) {
     if (gpr_atm_full_cas(&cancel_state_, original_state,
                          EncodeCancelStateError(error))) {
       if (original_state != 0) {
-        grpc_closure* notify_on_cancel = (grpc_closure*)original_state;
+        grpc_closure* notify_on_cancel =
+            reinterpret_cast<grpc_closure*>(original_state);
         if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
           gpr_log(GPR_INFO,
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",

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

@@ -23,9 +23,10 @@
 
 #include <stddef.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/support/atm.h>
 
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -208,7 +209,7 @@ class CallCombinerClosureList {
 
   // There are generally a maximum of 6 closures to run in the call
   // combiner, one for each pending op.
-  InlinedVector<CallCombinerClosure, 6> closures_;
+  absl::InlinedVector<CallCombinerClosure, 6> closures_;
 };
 
 }  // namespace grpc_core

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
+#include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
@@ -147,14 +148,15 @@ CFStreamHandle::CFStreamHandle(CFReadStreamRef read_stream,
       kCFStreamEventOpenCompleted | kCFStreamEventCanAcceptBytes |
           kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
       CFStreamHandle::WriteCallback, &ctx);
-  CFReadStreamSetDispatchQueue(read_stream, dispatch_queue_);
-  CFWriteStreamSetDispatchQueue(write_stream, dispatch_queue_);
+  grpc_apple_register_read_stream(read_stream, dispatch_queue_);
+  grpc_apple_register_write_stream(write_stream, dispatch_queue_);
 }
 
 CFStreamHandle::~CFStreamHandle() {
   open_event_.DestroyEvent();
   read_event_.DestroyEvent();
   write_event_.DestroyEvent();
+  dispatch_release(dispatch_queue_);
 }
 
 void CFStreamHandle::NotifyOnOpen(grpc_closure* closure) {
@@ -200,9 +202,9 @@ void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
 
 #else
 
-/* Creating a dummy function so that the grpc_cfstream library will be
+/* Creating a phony function so that the grpc_cfstream library will be
  * non-empty.
  */
-void CFStreamDummy() {}
+void CFStreamPhony() {}
 
 #endif