grpc 1.28.0.pre2 → 1.31.0.pre1

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <vector>
+
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -72,8 +74,9 @@ class GrpcUdpHandlerFactory {
 grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
 
 /* Start listening to bound ports. user_data is passed to callbacks. */
-void grpc_udp_server_start(grpc_udp_server* udp_server, grpc_pollset** pollsets,
-                           size_t pollset_count, void* user_data);
+void grpc_udp_server_start(grpc_udp_server* udp_server,
+                           const std::vector<grpc_pollset*>* pollsets,
+                           void* user_data);
 
 int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 

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

@@ -28,6 +28,8 @@
 #include <sys/types.h>
 #include <sys/un.h>
 
+#include "absl/strings/str_cat.h"
+
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #include <grpc/support/alloc.h>
@@ -44,14 +46,10 @@ grpc_error* grpc_resolve_unix_domain_address(const char* name,
   struct sockaddr_un* un;
   if (strlen(name) >
       GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
-    char* err_msg;
-    grpc_error* err;
-    gpr_asprintf(&err_msg,
-                 "Path name should not have more than %" PRIuPTR " characters.",
-                 GPR_ARRAY_SIZE(un->sun_path) - 1);
-    err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_msg);
-    gpr_free(err_msg);
-    return err;
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Path name should not have more than ",
+                     GPR_ARRAY_SIZE(un->sun_path) - 1, " characters")
+            .c_str());
   }
   *addrs = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
@@ -88,17 +86,14 @@ void grpc_unlink_if_unix_domain_socket(
   }
 }
 
-char* grpc_sockaddr_to_uri_unix_if_possible(
+std::string grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr) {
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family != AF_UNIX) {
-    return nullptr;
+    return "";
   }
-
-  char* result;
-  gpr_asprintf(&result, "unix:%s", ((struct sockaddr_un*)addr)->sun_path);
-  return result;
+  return absl::StrCat("unix:", ((struct sockaddr_un*)addr)->sun_path);
 }
 
 #endif

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/string_util.h>
@@ -37,7 +39,7 @@ int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* resolved_addr);
 
-char* grpc_sockaddr_to_uri_unix_if_possible(
+std::string grpc_sockaddr_to_uri_unix_if_possible(
     const grpc_resolved_address* resolved_addr);
 
 #endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */

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

@@ -22,6 +22,8 @@
 
 #ifndef GRPC_HAVE_UNIX_SOCKET
 
+#include <string>
+
 #include <grpc/support/log.h>
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
@@ -42,8 +44,9 @@ int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
 
 void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}
 
-char* grpc_sockaddr_to_uri_unix_if_possible(const grpc_resolved_address* addr) {
-  return NULL;
+std::string grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* addr) {
+  return "";
 }
 
 #endif

data/src/core/lib/json/json.h

@@ -27,7 +27,8 @@
 #include <string>
 #include <vector>
 
-#include "src/core/lib/gprpp/string_view.h"
+#include "absl/strings/string_view.h"
+
 #include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
@@ -55,7 +56,7 @@ class Json {
   using Array = std::vector<Json>;
 
   // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(StringView json_str, grpc_error** error);
+  static Json Parse(absl::string_view json_str, grpc_error** error);
 
   Json() = default;
 

data/src/core/lib/json/json_reader.cc

@@ -20,8 +20,12 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/json/json.h"
 
@@ -34,7 +38,7 @@ namespace {
 
 class JsonReader {
  public:
-  static grpc_error* Parse(StringView input, Json* output);
+  static grpc_error* Parse(absl::string_view input, Json* output);
 
  private:
   enum class Status {
@@ -80,7 +84,7 @@ class JsonReader {
    */
   static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
 
-  explicit JsonReader(StringView input)
+  explicit JsonReader(absl::string_view input)
       : original_input_(reinterpret_cast<const uint8_t*>(input.data())),
         input_(original_input_),
         remaining_input_(input.size()) {}
@@ -176,11 +180,10 @@ Json* JsonReader::CreateAndLinkValue() {
         if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
           truncated_errors_ = true;
         } else {
-          char* msg;
-          gpr_asprintf(&msg, "duplicate key \"%s\" at index %" PRIuPTR,
-                       key_.c_str(), CurrentIndex());
-          errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-          gpr_free(msg);
+          errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+              absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_,
+                              CurrentIndex())
+                  .c_str()));
         }
       }
       value = &(*parent->mutable_object())[std::move(key_)];
@@ -198,11 +201,10 @@ bool JsonReader::StartContainer(Json::Type type) {
     if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
       truncated_errors_ = true;
     } else {
-      char* msg;
-      gpr_asprintf(&msg, "exceeded max stack depth (%d) at index %" PRIuPTR,
-                   GRPC_JSON_MAX_DEPTH, CurrentIndex());
-      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-      gpr_free(msg);
+      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrFormat("exceeded max stack depth (%d) at index %" PRIuPTR,
+                          GRPC_JSON_MAX_DEPTH, CurrentIndex())
+              .c_str()));
     }
     return false;
   }
@@ -235,7 +237,7 @@ void JsonReader::SetString() {
 
 bool JsonReader::SetNumber() {
   Json* value = CreateAndLinkValue();
-  *value = Json(std::move(string_), /*is_number=*/true);
+  *value = Json(string_, /*is_number=*/true);
   string_.clear();
   return true;
 }
@@ -815,7 +817,7 @@ JsonReader::Status JsonReader::Run() {
   GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
 }
 
-grpc_error* JsonReader::Parse(StringView input, Json* output) {
+grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
   JsonReader reader(input);
   Status status = reader.Run();
   if (reader.truncated_errors_) {
@@ -824,17 +826,14 @@ grpc_error* JsonReader::Parse(StringView input, Json* output) {
         "errors and try again to see additional errors"));
   }
   if (status == Status::GRPC_JSON_INTERNAL_ERROR) {
-    char* msg;
-    gpr_asprintf(&msg, "internal error in JSON parser at index %" PRIuPTR,
-                 reader.CurrentIndex());
-    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-    gpr_free(msg);
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("internal error in JSON parser at index ",
+                     reader.CurrentIndex())
+            .c_str()));
   } else if (status == Status::GRPC_JSON_PARSE_ERROR) {
-    char* msg;
-    gpr_asprintf(&msg, "JSON parse error at index %" PRIuPTR,
-                 reader.CurrentIndex());
-    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-    gpr_free(msg);
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("JSON parse error at index ", reader.CurrentIndex())
+            .c_str()));
   }
   if (!reader.errors_.empty()) {
     return GRPC_ERROR_CREATE_FROM_VECTOR("JSON parsing failed",
@@ -846,7 +845,7 @@ grpc_error* JsonReader::Parse(StringView input, Json* output) {
 
 }  // namespace
 
-Json Json::Parse(StringView json_str, grpc_error** error) {
+Json Json::Parse(absl::string_view json_str, grpc_error** error) {
   Json value;
   *error = JsonReader::Parse(json_str, &value);
   return value;

data/src/core/lib/json/json_writer.cc

@@ -21,13 +21,13 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/json/json.h"
 
-#include "src/core/lib/gprpp/string_view.h"
-
 namespace grpc_core {
 
 namespace {
@@ -52,7 +52,7 @@ class JsonWriter {
 
   void OutputCheck(size_t needed);
   void OutputChar(char c);
-  void OutputString(const StringView str);
+  void OutputString(const absl::string_view str);
   void OutputIndent();
   void ValueEnd();
   void EscapeUtf16(uint16_t utf16);
@@ -92,7 +92,7 @@ void JsonWriter::OutputChar(char c) {
   output_.push_back(c);
 }
 
-void JsonWriter::OutputString(const StringView str) {
+void JsonWriter::OutputString(const absl::string_view str) {
   OutputCheck(str.size());
   output_.append(str.data(), str.size());
 }
@@ -110,11 +110,12 @@ void JsonWriter::OutputIndent() {
     return;
   }
   while (spaces >= (sizeof(spacesstr) - 1)) {
-    OutputString(StringView(spacesstr, sizeof(spacesstr) - 1));
+    OutputString(absl::string_view(spacesstr, sizeof(spacesstr) - 1));
     spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1);
   }
   if (spaces == 0) return;
-  OutputString(StringView(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces));
+  OutputString(
+      absl::string_view(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces));
 }
 
 void JsonWriter::ValueEnd() {
@@ -131,7 +132,7 @@ void JsonWriter::ValueEnd() {
 
 void JsonWriter::EscapeUtf16(uint16_t utf16) {
   static const char hex[] = "0123456789abcdef";
-  OutputString(StringView("\\u", 2));
+  OutputString(absl::string_view("\\u", 2));
   OutputChar(hex[(utf16 >> 12) & 0x0f]);
   OutputChar(hex[(utf16 >> 8) & 0x0f]);
   OutputChar(hex[(utf16 >> 4) & 0x0f]);
@@ -150,19 +151,19 @@ void JsonWriter::EscapeString(const std::string& string) {
     } else if (c < 32 || c == 127) {
       switch (c) {
         case '\b':
-          OutputString(StringView("\\b", 2));
+          OutputString(absl::string_view("\\b", 2));
           break;
         case '\f':
-          OutputString(StringView("\\f", 2));
+          OutputString(absl::string_view("\\f", 2));
           break;
         case '\n':
-          OutputString(StringView("\\n", 2));
+          OutputString(absl::string_view("\\n", 2));
           break;
         case '\r':
-          OutputString(StringView("\\r", 2));
+          OutputString(absl::string_view("\\r", 2));
           break;
         case '\t':
-          OutputString(StringView("\\t", 2));
+          OutputString(absl::string_view("\\t", 2));
           break;
         default:
           EscapeUtf16(c);

data/src/core/lib/security/credentials/composite/composite_credentials.cc

@@ -22,7 +22,10 @@
 
 #include <cstring>
 #include <new>
+#include <vector>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -116,6 +119,15 @@ void grpc_composite_call_credentials::cancel_get_request_metadata(
   GRPC_ERROR_UNREF(error);
 }
 
+std::string grpc_composite_call_credentials::debug_string() {
+  std::vector<std::string> outputs;
+  for (auto& inner_cred : inner_) {
+    outputs.emplace_back(inner_cred->debug_string());
+  }
+  return absl::StrCat("CompositeCallCredentials{", absl::StrJoin(outputs, ","),
+                      "}");
+}
+
 static size_t get_creds_array_size(const grpc_call_credentials* creds,
                                    bool is_composite) {
   return is_composite

data/src/core/lib/security/credentials/composite/composite_credentials.h

@@ -21,7 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/inlined_vector.h"
+#include <string>
+
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/security/credentials/credentials.h"
 
@@ -69,8 +72,7 @@ class grpc_composite_channel_credentials : public grpc_channel_credentials {
 class grpc_composite_call_credentials : public grpc_call_credentials {
  public:
   using CallCredentialsList =
-      grpc_core::InlinedVector<grpc_core::RefCountedPtr<grpc_call_credentials>,
-                               2>;
+      absl::InlinedVector<grpc_core::RefCountedPtr<grpc_call_credentials>, 2>;
 
   grpc_composite_call_credentials(
       grpc_core::RefCountedPtr<grpc_call_credentials> creds1,
@@ -91,6 +93,7 @@ class grpc_composite_call_credentials : public grpc_call_credentials {
   }
 
   const CallCredentialsList& inner() const { return inner_; }
+  std::string debug_string() override;
 
  private:
   void push_to_inner(grpc_core::RefCountedPtr<grpc_call_credentials> creds,

data/src/core/lib/security/credentials/credentials.cc

@@ -45,90 +45,6 @@ void grpc_channel_credentials_release(grpc_channel_credentials* creds) {
   if (creds) creds->Unref();
 }
 
-static std::map<grpc_core::UniquePtr<char>,
-                grpc_core::RefCountedPtr<grpc_channel_credentials>,
-                grpc_core::StringLess>* g_grpc_control_plane_creds;
-static gpr_mu g_control_plane_creds_mu;
-
-static void do_control_plane_creds_init() {
-  gpr_mu_init(&g_control_plane_creds_mu);
-  GPR_ASSERT(g_grpc_control_plane_creds == nullptr);
-  g_grpc_control_plane_creds =
-      new std::map<grpc_core::UniquePtr<char>,
-                   grpc_core::RefCountedPtr<grpc_channel_credentials>,
-                   grpc_core::StringLess>();
-}
-
-void grpc_control_plane_credentials_init() {
-  static gpr_once once_init_control_plane_creds = GPR_ONCE_INIT;
-  gpr_once_init(&once_init_control_plane_creds, do_control_plane_creds_init);
-}
-
-void grpc_test_only_control_plane_credentials_destroy() {
-  delete g_grpc_control_plane_creds;
-  g_grpc_control_plane_creds = nullptr;
-  gpr_mu_destroy(&g_control_plane_creds_mu);
-}
-
-void grpc_test_only_control_plane_credentials_force_init() {
-  if (g_grpc_control_plane_creds == nullptr) {
-    do_control_plane_creds_init();
-  }
-}
-
-bool grpc_channel_credentials_attach_credentials(
-    grpc_channel_credentials* credentials, const char* authority,
-    grpc_channel_credentials* control_plane_creds) {
-  grpc_core::ExecCtx exec_ctx;
-  return credentials->attach_credentials(authority, control_plane_creds->Ref());
-}
-
-bool grpc_control_plane_credentials_register(
-    const char* authority, grpc_channel_credentials* control_plane_creds) {
-  grpc_core::ExecCtx exec_ctx;
-  {
-    grpc_core::MutexLock lock(&g_control_plane_creds_mu);
-    auto key = grpc_core::UniquePtr<char>(gpr_strdup(authority));
-    if (g_grpc_control_plane_creds->find(key) !=
-        g_grpc_control_plane_creds->end()) {
-      return false;
-    }
-    (*g_grpc_control_plane_creds)[std::move(key)] = control_plane_creds->Ref();
-  }
-  return true;
-}
-
-bool grpc_channel_credentials::attach_credentials(
-    const char* authority,
-    grpc_core::RefCountedPtr<grpc_channel_credentials> control_plane_creds) {
-  auto key = grpc_core::UniquePtr<char>(gpr_strdup(authority));
-  if (local_control_plane_creds_.find(key) !=
-      local_control_plane_creds_.end()) {
-    return false;
-  }
-  local_control_plane_creds_[std::move(key)] = std::move(control_plane_creds);
-  return true;
-}
-
-grpc_core::RefCountedPtr<grpc_channel_credentials>
-grpc_channel_credentials::get_control_plane_credentials(const char* authority) {
-  {
-    auto key = grpc_core::UniquePtr<char>(gpr_strdup(authority));
-    auto local_lookup = local_control_plane_creds_.find(key);
-    if (local_lookup != local_control_plane_creds_.end()) {
-      return local_lookup->second;
-    }
-    {
-      grpc_core::MutexLock lock(&g_control_plane_creds_mu);
-      auto global_lookup = g_grpc_control_plane_creds->find(key);
-      if (global_lookup != g_grpc_control_plane_creds->end()) {
-        return global_lookup->second;
-      }
-    }
-  }
-  return duplicate_without_call_credentials();
-}
-
 void grpc_call_credentials_release(grpc_call_credentials* creds) {
   GRPC_API_TRACE("grpc_call_credentials_release(creds=%p)", 1, (creds));
   grpc_core::ExecCtx exec_ctx;