grpc 1.28.0 → 1.31.0.pre2

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

@@ -21,28 +21,24 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/string_view.h"
+#include <string>
 
-namespace grpc_core {
-
-/** Given a host and port, creates a newly-allocated string of the form
-   "host:port" or "[ho:st]:port", depending on whether the host contains colons
-   like an IPv6 literal.  If the host is already bracketed, then additional
-   brackets will not be added.
+#include "absl/strings/string_view.h"
 
-   Usage is similar to gpr_asprintf: returns the number of bytes written
-   (excluding the final '\0'), and *out points to a string.
+namespace grpc_core {
 
-   In the unlikely event of an error, returns -1 and sets *out to NULL. */
-int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port);
+// Given a host and port, creates a newly-allocated string of the form
+// "host:port" or "[ho:st]:port", depending on whether the host contains colons
+// like an IPv6 literal.  If the host is already bracketed, then additional
+// brackets will not be added.
+std::string JoinHostPort(absl::string_view host, int port);
 
 /** Given a name in the form "host:port" or "[ho:st]:port", split into hostname
    and port number.
 
    There are two variants of this method:
-   1) StringView output: port and host are returned as views on name.
-   2) char* output: port and host are copied into newly allocated strings.
+   1) absl::string_view output: port and host are returned as views on name.
+   2) std::string output: port and host are copied into newly allocated strings.
 
    Prefer variant (1) over (2), because no allocation or copy is performed in
    variant (1).  Use (2) only when interacting with C API that mandate
@@ -50,9 +46,10 @@ int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port);
 
    Return true on success, false on failure. Guarantees *host and *port are
    cleared on failure. */
-bool SplitHostPort(StringView name, StringView* host, StringView* port);
-bool SplitHostPort(StringView name, grpc_core::UniquePtr<char>* host,
-                   grpc_core::UniquePtr<char>* port);
+bool SplitHostPort(absl::string_view name, absl::string_view* host,
+                   absl::string_view* port);
+bool SplitHostPort(absl::string_view name, std::string* host,
+                   std::string* port);
 
 }  // namespace grpc_core
 

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

@@ -25,8 +25,9 @@
 
 #include <map>
 
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/string_view.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
@@ -38,7 +39,8 @@ struct StringLess {
                   const grpc_core::UniquePtr<char>& b) const {
     return strcmp(a.get(), b.get()) < 0;
   }
-  bool operator()(const StringView& a, const StringView& b) const {
+  bool operator()(const absl::string_view& a,
+                  const absl::string_view& b) const {
     const size_t min_size = std::min(a.size(), b.size());
     int c = strncmp(a.data(), b.data(), min_size);
     if (c != 0) return c < 0;
@@ -46,14 +48,6 @@ struct StringLess {
   }
 };
 
-template <typename T>
-struct RefCountedPtrLess {
-  bool operator()(const RefCountedPtr<T>& p1,
-                  const RefCountedPtr<T>& p2) const {
-    return p1.get() < p2.get();
-  }
-};
-
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_MAP_H */

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

@@ -182,6 +182,11 @@ inline RefCountedPtr<T> MakeRefCounted(Args&&... args) {
   return RefCountedPtr<T>(new T(std::forward<Args>(args)...));
 }
 
+template <typename T>
+bool operator<(const RefCountedPtr<T>& p1, const RefCountedPtr<T>& p2) {
+  return p1.get() < p2.get();
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_REF_COUNTED_PTR_H */

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

@@ -24,99 +24,80 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
 
 static void fill_common_header(const grpc_httpcli_request* request,
-                               gpr_strvec* buf, bool connection_close) {
-  size_t i;
-  gpr_strvec_add(buf, gpr_strdup(request->http.path));
-  gpr_strvec_add(buf, gpr_strdup(" HTTP/1.0\r\n"));
+                               bool connection_close,
+                               std::vector<std::string>* buf) {
+  buf->push_back(request->http.path);
+  buf->push_back(" HTTP/1.0\r\n");
   /* just in case some crazy server really expects HTTP/1.1 */
-  gpr_strvec_add(buf, gpr_strdup("Host: "));
-  gpr_strvec_add(buf, gpr_strdup(request->host));
-  gpr_strvec_add(buf, gpr_strdup("\r\n"));
-  if (connection_close)
-    gpr_strvec_add(buf, gpr_strdup("Connection: close\r\n"));
-  gpr_strvec_add(buf,
-                 gpr_strdup("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n"));
+  buf->push_back("Host: ");
+  buf->push_back(request->host);
+  buf->push_back("\r\n");
+  if (connection_close) buf->push_back("Connection: close\r\n");
+  buf->push_back("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n");
   /* user supplied headers */
-  for (i = 0; i < request->http.hdr_count; i++) {
-    gpr_strvec_add(buf, gpr_strdup(request->http.hdrs[i].key));
-    gpr_strvec_add(buf, gpr_strdup(": "));
-    gpr_strvec_add(buf, gpr_strdup(request->http.hdrs[i].value));
-    gpr_strvec_add(buf, gpr_strdup("\r\n"));
+  for (size_t i = 0; i < request->http.hdr_count; i++) {
+    buf->push_back(request->http.hdrs[i].key);
+    buf->push_back(": ");
+    buf->push_back(request->http.hdrs[i].value);
+    buf->push_back("\r\n");
   }
 }
 
 grpc_slice grpc_httpcli_format_get_request(
     const grpc_httpcli_request* request) {
-  gpr_strvec out;
-  char* flat;
-  size_t flat_len;
-
-  gpr_strvec_init(&out);
-  gpr_strvec_add(&out, gpr_strdup("GET "));
-  fill_common_header(request, &out, true);
-  gpr_strvec_add(&out, gpr_strdup("\r\n"));
-
-  flat = gpr_strvec_flatten(&out, &flat_len);
-  gpr_strvec_destroy(&out);
-
-  return grpc_slice_new(flat, flat_len, gpr_free);
+  std::vector<std::string> out;
+  out.push_back("GET ");
+  fill_common_header(request, true, &out);
+  out.push_back("\r\n");
+  std::string req = absl::StrJoin(out, "");
+  return grpc_slice_from_copied_buffer(req.data(), req.size());
 }
 
 grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request* request,
                                             const char* body_bytes,
                                             size_t body_size) {
-  gpr_strvec out;
-  char* tmp;
-  size_t out_len;
-  size_t i;
-
-  gpr_strvec_init(&out);
-
-  gpr_strvec_add(&out, gpr_strdup("POST "));
-  fill_common_header(request, &out, true);
-  if (body_bytes) {
-    uint8_t has_content_type = 0;
-    for (i = 0; i < request->http.hdr_count; i++) {
+  std::vector<std::string> out;
+  out.push_back("POST ");
+  fill_common_header(request, true, &out);
+  if (body_bytes != nullptr) {
+    bool has_content_type = false;
+    for (size_t i = 0; i < request->http.hdr_count; i++) {
       if (strcmp(request->http.hdrs[i].key, "Content-Type") == 0) {
-        has_content_type = 1;
+        has_content_type = true;
         break;
       }
     }
     if (!has_content_type) {
-      gpr_strvec_add(&out, gpr_strdup("Content-Type: text/plain\r\n"));
+      out.push_back("Content-Type: text/plain\r\n");
     }
-    gpr_asprintf(&tmp, "Content-Length: %lu\r\n",
-                 static_cast<unsigned long>(body_size));
-    gpr_strvec_add(&out, tmp);
+    out.push_back(absl::StrFormat("Content-Length: %lu\r\n",
+                                  static_cast<unsigned long>(body_size)));
   }
-  gpr_strvec_add(&out, gpr_strdup("\r\n"));
-  tmp = gpr_strvec_flatten(&out, &out_len);
-  gpr_strvec_destroy(&out);
-
-  if (body_bytes) {
-    tmp = static_cast<char*>(gpr_realloc(tmp, out_len + body_size));
-    memcpy(tmp + out_len, body_bytes, body_size);
-    out_len += body_size;
+  out.push_back("\r\n");
+  std::string req = absl::StrJoin(out, "");
+  if (body_bytes != nullptr) {
+    absl::StrAppend(&req, absl::string_view(body_bytes, body_size));
   }
-
-  return grpc_slice_new(tmp, out_len, gpr_free);
+  return grpc_slice_from_copied_buffer(req.data(), req.size());
 }
 
 grpc_slice grpc_httpcli_format_connect_request(
     const grpc_httpcli_request* request) {
-  gpr_strvec out;
-  gpr_strvec_init(&out);
-  gpr_strvec_add(&out, gpr_strdup("CONNECT "));
-  fill_common_header(request, &out, false);
-  gpr_strvec_add(&out, gpr_strdup("\r\n"));
-  size_t flat_len;
-  char* flat = gpr_strvec_flatten(&out, &flat_len);
-  gpr_strvec_destroy(&out);
-  return grpc_slice_new(flat, flat_len, gpr_free);
+  std::vector<std::string> out;
+  out.push_back("CONNECT ");
+  fill_common_header(request, false, &out);
+  out.push_back("\r\n");
+  std::string req = absl::StrJoin(out, "");
+  return grpc_slice_from_copied_buffer(req.data(), req.size());
 }

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

@@ -22,6 +22,10 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -38,7 +42,7 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-typedef struct {
+struct internal_request {
   grpc_slice request_text;
   grpc_http_parser parser;
   grpc_resolved_addresses* addresses;
@@ -60,8 +64,7 @@ typedef struct {
   grpc_closure connected;
   grpc_error* overall_error;
   grpc_resource_quota* resource_quota;
-} internal_request;
-
+};
 static grpc_httpcli_get_override g_get_override = nullptr;
 static grpc_httpcli_post_override g_post_override = nullptr;
 
@@ -113,11 +116,11 @@ static void append_error(internal_request* req, grpc_error* error) {
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
   grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  grpc_core::UniquePtr<char> addr_text(grpc_sockaddr_to_uri(addr));
+  std::string addr_text = grpc_sockaddr_to_uri(addr);
   req->overall_error = grpc_error_add_child(
       req->overall_error,
       grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_moved_string(std::move(addr_text))));
+                         grpc_slice_from_cpp_string(std::move(addr_text))));
 }
 
 static void do_read(internal_request* req) {
@@ -267,15 +270,14 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
-  char* name;
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
   internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name,
+                         on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
-  gpr_free(name);
 }
 
 void grpc_httpcli_post(grpc_httpcli_context* context,
@@ -285,16 +287,16 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response) {
-  char* name;
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
       context, pollent, resource_quota, request, deadline, on_done, response,
-      name, grpc_httpcli_format_post_request(request, body_bytes, body_size));
-  gpr_free(name);
+      name.c_str(),
+      grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,

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;
 

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"
@@ -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);

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 {