grpc 1.26.0 → 1.30.0

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

@@ -164,7 +164,7 @@ class ThreadState {
   int count_;
 };
 
-}  // namespace
+}  // namespace internal
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {

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

@@ -20,44 +20,36 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 
-#include <string.h>
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
-int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port) {
-  char* tmp;
-  int ret;
-  if (host[0] != '[' && strchr(host, ':') != nullptr) {
-    /* IPv6 literals must be enclosed in brackets. */
-    ret = gpr_asprintf(&tmp, "[%s]:%d", host, port);
-  } else {
-    /* Ordinary non-bracketed host:port. */
-    ret = gpr_asprintf(&tmp, "%s:%d", host, port);
+
+std::string JoinHostPort(absl::string_view host, int port) {
+  if (!host.empty() && host[0] != '[' && host.rfind(':') != host.npos) {
+    // IPv6 literals must be enclosed in brackets.
+    return absl::StrFormat("[%s]:%d", host, port);
   }
-  out->reset(tmp);
-  return ret;
+  // Ordinary non-bracketed host:port.
+  return absl::StrFormat("%s:%d", host, port);
 }
 
 namespace {
-bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
-                     bool* has_port) {
+bool DoSplitHostPort(absl::string_view name, absl::string_view* host,
+                     absl::string_view* port, bool* has_port) {
   *has_port = false;
-  if (name[0] == '[') {
+  if (!name.empty() && name[0] == '[') {
     /* Parse a bracketed host, typically an IPv6 literal. */
     const size_t rbracket = name.find(']', 1);
-    if (rbracket == grpc_core::StringView::npos) {
+    if (rbracket == absl::string_view::npos) {
       /* Unmatched [ */
       return false;
     }
     if (rbracket == name.size() - 1) {
       /* ]<end> */
-      *port = StringView();
+      *port = absl::string_view();
     } else if (name[rbracket + 1] == ':') {
       /* ]:<port?> */
       *port = name.substr(rbracket + 2, name.size() - rbracket - 2);
@@ -67,16 +59,16 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
       return false;
     }
     *host = name.substr(1, rbracket - 1);
-    if (host->find(':') == grpc_core::StringView::npos) {
+    if (host->find(':') == absl::string_view::npos) {
       /* Require all bracketed hosts to contain a colon, because a hostname or
          IPv4 address should never use brackets. */
-      *host = StringView();
+      *host = absl::string_view();
       return false;
     }
   } else {
     size_t colon = name.find(':');
-    if (colon != grpc_core::StringView::npos &&
-        name.find(':', colon + 1) == grpc_core::StringView::npos) {
+    if (colon != absl::string_view::npos &&
+        name.find(':', colon + 1) == absl::string_view::npos) {
       /* Exactly 1 colon.  Split into host:port. */
       *host = name.substr(0, colon);
       *port = name.substr(colon + 1, name.size() - colon - 1);
@@ -84,35 +76,37 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
     } else {
       /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
       *host = name;
-      *port = StringView();
+      *port = absl::string_view();
     }
   }
   return true;
 }
 }  // namespace
 
-bool SplitHostPort(StringView name, StringView* host, StringView* port) {
+bool SplitHostPort(absl::string_view name, absl::string_view* host,
+                   absl::string_view* port) {
   bool unused;
   return DoSplitHostPort(name, host, port, &unused);
 }
 
-bool SplitHostPort(StringView name, grpc_core::UniquePtr<char>* host,
-                   grpc_core::UniquePtr<char>* port) {
-  GPR_DEBUG_ASSERT(host != nullptr && *host == nullptr);
-  GPR_DEBUG_ASSERT(port != nullptr && *port == nullptr);
-  StringView host_view;
-  StringView port_view;
+bool SplitHostPort(absl::string_view name, std::string* host,
+                   std::string* port) {
+  GPR_DEBUG_ASSERT(host != nullptr && host->empty());
+  GPR_DEBUG_ASSERT(port != nullptr && port->empty());
+  absl::string_view host_view;
+  absl::string_view port_view;
   bool has_port;
   const bool ret = DoSplitHostPort(name, &host_view, &port_view, &has_port);
   if (ret) {
     // We always set the host, but port is set only when DoSplitHostPort find a
     // port in the string, to remain backward compatible with the old
     // gpr_split_host_port API.
-    *host = StringViewToCString(host_view);
+    *host = std::string(host_view);
     if (has_port) {
-      *port = StringViewToCString(port_view);
+      *port = std::string(port_view);
     }
   }
   return ret;
 }
+
 }  // namespace grpc_core

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* 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/memory.h

@@ -28,6 +28,8 @@
 #include <memory>
 #include <utility>
 
+#include "absl/memory/memory.h"
+
 namespace grpc_core {
 
 class DefaultDeleteChar {
@@ -44,12 +46,6 @@ class DefaultDeleteChar {
 template <typename T>
 using UniquePtr = std::unique_ptr<T, DefaultDeleteChar>;
 
-// TODO(veblush): Replace this with absl::make_unique once abseil is added.
-template <typename T, typename... Args>
-inline std::unique_ptr<T> MakeUnique(Args&&... args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_MEMORY_H */

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

@@ -182,6 +182,11 @@ inline RefCountedPtr 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/gprpp/sync.h

@@ -117,6 +117,15 @@ class CondVar {
     }
   }
 
+  // Returns true iff we timed-out
+  template <typename Predicate>
+  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) {
+    while (!pred()) {
+      if (Wait(mu, deadline)) return true;
+    }
+    return false;
+  }
+
  private:
   gpr_cv cv_;
 };

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

@@ -38,7 +38,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 +60,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;
 

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;