grpc 1.28.0 → 1.30.0

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

@@ -23,12 +23,11 @@
 
 #include "src/core/lib/iomgr/timer.h"
 
-typedef struct {
+struct grpc_timer_heap {
   grpc_timer** timers;
   uint32_t timer_count;
   uint32_t timer_capacity;
-} grpc_timer_heap;
-
+};
 /* return true if the new timer is the first timer in the heap */
 bool grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer);
 

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

@@ -44,6 +44,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -52,7 +54,6 @@
 #include <grpc/support/time.h>
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -147,11 +148,9 @@ GrpcUdpListener::GrpcUdpListener(grpc_udp_server* server, int fd,
       server_(server),
       orphan_notified_(false),
       already_shutdown_(false) {
-  char* addr_str;
   char* name;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_asprintf(&name, "udp-server-listener:%s", addr_str);
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  gpr_asprintf(&name, "udp-server-listener:%s", addr_str.c_str());
   emfd_ = grpc_fd_create(fd, name, true);
   memcpy(&addr_, addr, sizeof(grpc_resolved_address));
   GPR_ASSERT(emfd_);
@@ -177,7 +176,7 @@ struct grpc_udp_server {
   int shutdown;
 
   /* An array of listeners */
-  grpc_core::InlinedVector<GrpcUdpListener, 16> listeners;
+  absl::InlinedVector<GrpcUdpListener, 16> listeners;
 
   /* factory for use to create udp listeners */
   GrpcUdpHandlerFactory* handler_factory;
@@ -412,10 +411,8 @@ static int prepare_socket(grpc_socket_factory* socket_factory, int fd,
   }
 
   if (bind_socket(socket_factory, fd, addr) < 0) {
-    char* addr_str;
-    grpc_sockaddr_to_string(&addr_str, addr, 0);
-    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
-    gpr_free(addr_str);
+    std::string addr_str = grpc_sockaddr_to_string(addr, false);
+    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str.c_str(), strerror(errno));
     goto error;
   }
 
@@ -582,10 +579,8 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
             "Try to have multiple listeners on same port, but SO_REUSEPORT is "
             "not supported. Only create 1 listener.");
   }
-  char* addr_str;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str);
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str.c_str());
 
   int allocated_port1 = -1;
   int allocated_port2 = -1;

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

@@ -34,7 +34,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 +80,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()) {}
@@ -235,7 +235,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 +815,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_) {
@@ -846,7 +846,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;

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

@@ -21,14 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/sync.h>
 #include "src/core/lib/transport/metadata_batch.h"
 
-#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -129,29 +129,10 @@ struct grpc_channel_credentials
     return args;
   }
 
-  // Attaches control_plane_creds to the local registry, under authority,
-  // if no other creds are currently registered under authority. Returns
-  // true if registered successfully and false if not.
-  bool attach_credentials(
-      const char* authority,
-      grpc_core::RefCountedPtr<grpc_channel_credentials> control_plane_creds);
-
-  // Gets the control plane credentials registered under authority. This
-  // prefers the local control plane creds registry but falls back to the
-  // global registry. Lastly, this returns self but with any attached
-  // call credentials stripped off, in the case that neither the local
-  // registry nor the global registry have an entry for authority.
-  grpc_core::RefCountedPtr<grpc_channel_credentials>
-  get_control_plane_credentials(const char* authority);
-
   const char* type() const { return type_; }
 
  private:
   const char* type_;
-  std::map<grpc_core::UniquePtr<char>,
-           grpc_core::RefCountedPtr<grpc_channel_credentials>,
-           grpc_core::StringLess>
-      local_control_plane_creds_;
 };
 
 /* Util to encapsulate the channel credentials in a channel arg. */
@@ -165,48 +146,12 @@ grpc_channel_credentials* grpc_channel_credentials_from_arg(
 grpc_channel_credentials* grpc_channel_credentials_find_in_args(
     const grpc_channel_args* args);
 
-/** EXPERIMENTAL.  API MAY CHANGE IN THE FUTURE.
-    Attaches \a control_plane_creds to \a credentials
-    under the key \a authority. Returns false if \a authority
-    is already present, in which case no changes are made.
-    Note that this API is not thread safe. Only one thread may
-    attach control plane creds to a given credentials object at
-    any one time, and new control plane creds must not be
-    attached after \a credentials has been used to create a channel. */
-bool grpc_channel_credentials_attach_credentials(
-    grpc_channel_credentials* credentials, const char* authority,
-    grpc_channel_credentials* control_plane_creds);
-
-/** EXPERIMENTAL.  API MAY CHANGE IN THE FUTURE.
-    Registers \a control_plane_creds in the global registry
-    under the key \a authority. Returns false if \a authority
-    is already present, in which case no changes are made. */
-bool grpc_control_plane_credentials_register(
-    const char* authority, grpc_channel_credentials* control_plane_creds);
-
-/* Initializes global control plane credentials data. */
-void grpc_control_plane_credentials_init();
-
-/* Test only: destroy global control plane credentials data.
- * This API is meant for use by a few tests that need to
- * satisdy grpc_core::LeakDetector. */
-void grpc_test_only_control_plane_credentials_destroy();
-
-/* Test only: force re-initialization of global control
- * plane credentials data if it was previously destroyed.
- * This API is meant to be used in
- * tandem with the
- * grpc_test_only_control_plane_credentials_destroy, for
- * the few tests that need it. */
-void grpc_test_only_control_plane_credentials_force_init();
-
 /* --- grpc_credentials_mdelem_array. --- */
 
-typedef struct {
+struct grpc_credentials_mdelem_array {
   grpc_mdelem* md = nullptr;
   size_t size = 0;
-} grpc_credentials_mdelem_array;
-
+};
 /// Takes a new ref to \a md.
 void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list,
                                        grpc_mdelem md);
@@ -252,6 +197,10 @@ struct grpc_call_credentials
     return min_security_level_;
   }
 
+  virtual std::string debug_string() {
+    return "grpc_call_credentials did not provide debug string";
+  }
+
   const char* type() const { return type_; }
 
  private: