grpc 1.25.0 → 1.26.0

data/src/core/ext/filters/client_channel/lb_policy_registry.cc

@@ -34,7 +34,7 @@ class RegistryState {
   RegistryState() {}
 
   void RegisterLoadBalancingPolicyFactory(
-      UniquePtr<LoadBalancingPolicyFactory> factory) {
+      std::unique_ptr<LoadBalancingPolicyFactory> factory) {
     for (size_t i = 0; i < factories_.size(); ++i) {
       GPR_ASSERT(strcmp(factories_[i]->name(), factory->name()) != 0);
     }
@@ -52,7 +52,7 @@ class RegistryState {
   }
 
  private:
-  InlinedVector<UniquePtr<LoadBalancingPolicyFactory>, 10> factories_;
+  InlinedVector<std::unique_ptr<LoadBalancingPolicyFactory>, 10> factories_;
 };
 
 RegistryState* g_state = nullptr;
@@ -64,16 +64,16 @@ RegistryState* g_state = nullptr;
 //
 
 void LoadBalancingPolicyRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = New<RegistryState>();
+  if (g_state == nullptr) g_state = new RegistryState();
 }
 
 void LoadBalancingPolicyRegistry::Builder::ShutdownRegistry() {
-  Delete(g_state);
+  delete g_state;
   g_state = nullptr;
 }
 
 void LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
-    UniquePtr<LoadBalancingPolicyFactory> factory) {
+    std::unique_ptr<LoadBalancingPolicyFactory> factory) {
   InitRegistry();
   g_state->RegisterLoadBalancingPolicyFactory(std::move(factory));
 }

data/src/core/ext/filters/client_channel/lb_policy_registry.h

@@ -41,7 +41,7 @@ class LoadBalancingPolicyRegistry {
     /// Registers an LB policy factory.  The factory will be used to create an
     /// LB policy whose name matches that of the factory.
     static void RegisterLoadBalancingPolicyFactory(
-        UniquePtr<LoadBalancingPolicyFactory> factory);
+        std::unique_ptr<LoadBalancingPolicyFactory> factory);
   };
 
   /// Creates an LB policy of the type specified by \a name.

data/src/core/ext/filters/client_channel/local_subchannel_pool.cc

@@ -43,7 +43,7 @@ Subchannel* LocalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
     GRPC_SUBCHANNEL_UNREF(constructed, "subchannel_register+found_existing");
   } else {
     // There hasn't been such subchannel. Add one.
-    subchannel_map_ = grpc_avl_add(subchannel_map_, New<SubchannelKey>(*key),
+    subchannel_map_ = grpc_avl_add(subchannel_map_, new SubchannelKey(*key),
                                    constructed, nullptr);
     c = constructed;
   }
@@ -62,26 +62,26 @@ Subchannel* LocalSubchannelPool::FindSubchannel(SubchannelKey* key) {
 
 namespace {
 
-void sck_avl_destroy(void* p, void* user_data) {
+void sck_avl_destroy(void* p, void* /*user_data*/) {
   SubchannelKey* key = static_cast<SubchannelKey*>(p);
-  Delete(key);
+  delete key;
 }
 
-void* sck_avl_copy(void* p, void* unused) {
+void* sck_avl_copy(void* p, void* /*unused*/) {
   const SubchannelKey* key = static_cast<const SubchannelKey*>(p);
-  auto new_key = New<SubchannelKey>(*key);
+  auto new_key = new SubchannelKey(*key);
   return static_cast<void*>(new_key);
 }
 
-long sck_avl_compare(void* a, void* b, void* unused) {
+long sck_avl_compare(void* a, void* b, void* /*unused*/) {
   const SubchannelKey* key_a = static_cast<const SubchannelKey*>(a);
   const SubchannelKey* key_b = static_cast<const SubchannelKey*>(b);
   return key_a->Cmp(*key_b);
 }
 
-void scv_avl_destroy(void* p, void* user_data) {}
+void scv_avl_destroy(void* /*p*/, void* /*user_data*/) {}
 
-void* scv_avl_copy(void* p, void* unused) { return p; }
+void* scv_avl_copy(void* p, void* /*unused*/) { return p; }
 
 }  // namespace
 

data/src/core/ext/filters/client_channel/proxy_mapper.h

@@ -21,54 +21,34 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
-typedef struct grpc_proxy_mapper grpc_proxy_mapper;
+namespace grpc_core {
+
+class ProxyMapperInterface {
+ public:
+  virtual ~ProxyMapperInterface() = default;
 
-typedef struct {
   /// Determines the proxy name to resolve for \a server_uri.
   /// If no proxy is needed, returns false.
   /// Otherwise, sets \a name_to_resolve, optionally sets \a new_args,
   /// and returns true.
-  bool (*map_name)(grpc_proxy_mapper* mapper, const char* server_uri,
-                   const grpc_channel_args* args, char** name_to_resolve,
-                   grpc_channel_args** new_args);
+  virtual bool MapName(const char* server_uri, const grpc_channel_args* args,
+                       char** name_to_resolve,
+                       grpc_channel_args** new_args) = 0;
+
   /// Determines the proxy address to use to contact \a address.
   /// If no proxy is needed, returns false.
   /// Otherwise, sets \a new_address, optionally sets \a new_args, and
   /// returns true.
-  bool (*map_address)(grpc_proxy_mapper* mapper,
-                      const grpc_resolved_address* address,
-                      const grpc_channel_args* args,
-                      grpc_resolved_address** new_address,
-                      grpc_channel_args** new_args);
-  /// Destroys \a mapper.
-  void (*destroy)(grpc_proxy_mapper* mapper);
-} grpc_proxy_mapper_vtable;
-
-struct grpc_proxy_mapper {
-  const grpc_proxy_mapper_vtable* vtable;
+  virtual bool MapAddress(const grpc_resolved_address& address,
+                          const grpc_channel_args* args,
+                          grpc_resolved_address** new_address,
+                          grpc_channel_args** new_args) = 0;
 };
 
-void grpc_proxy_mapper_init(const grpc_proxy_mapper_vtable* vtable,
-                            grpc_proxy_mapper* mapper);
-
-bool grpc_proxy_mapper_map_name(grpc_proxy_mapper* mapper,
-                                const char* server_uri,
-                                const grpc_channel_args* args,
-                                char** name_to_resolve,
-                                grpc_channel_args** new_args);
-
-bool grpc_proxy_mapper_map_address(grpc_proxy_mapper* mapper,
-                                   const grpc_resolved_address* address,
-                                   const grpc_channel_args* args,
-                                   grpc_resolved_address** new_address,
-                                   grpc_channel_args** new_args);
-
-void grpc_proxy_mapper_destroy(grpc_proxy_mapper* mapper);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H */

data/src/core/ext/filters/client_channel/proxy_mapper_registry.cc

@@ -20,103 +20,70 @@
 
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 
-#include <string.h>
+#include <memory>
+#include <vector>
 
-#include <grpc/support/alloc.h>
+namespace grpc_core {
 
-//
-// grpc_proxy_mapper_list
-//
+namespace {
 
-typedef struct {
-  grpc_proxy_mapper** list;
-  size_t num_mappers;
-} grpc_proxy_mapper_list;
+using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
+ProxyMapperList* g_proxy_mapper_list;
 
-static void grpc_proxy_mapper_list_register(grpc_proxy_mapper_list* list,
-                                            bool at_start,
-                                            grpc_proxy_mapper* mapper) {
-  list->list = static_cast<grpc_proxy_mapper**>(gpr_realloc(
-      list->list, (list->num_mappers + 1) * sizeof(grpc_proxy_mapper*)));
+}  // namespace
+
+void ProxyMapperRegistry::Init() {
+  if (g_proxy_mapper_list == nullptr) {
+    g_proxy_mapper_list = new ProxyMapperList();
+  }
+}
+
+void ProxyMapperRegistry::Shutdown() {
+  delete g_proxy_mapper_list;
+  // Clean up in case we re-initialze later.
+  // TODO(roth): This should ideally live in Init().  However, if we did this
+  // there, then we would do it AFTER we start registering proxy mappers from
+  // third-party plugins, so they'd never show up (and would leak memory).
+  // We probably need some sort of dependency system for plugins to fix
+  // this.
+  g_proxy_mapper_list = nullptr;
+}
+
+void ProxyMapperRegistry::Register(
+    bool at_start, std::unique_ptr<ProxyMapperInterface> mapper) {
+  Init();
   if (at_start) {
-    memmove(list->list + 1, list->list,
-            sizeof(grpc_proxy_mapper*) * list->num_mappers);
-    list->list[0] = mapper;
+    g_proxy_mapper_list->insert(g_proxy_mapper_list->begin(),
+                                std::move(mapper));
   } else {
-    list->list[list->num_mappers] = mapper;
+    g_proxy_mapper_list->emplace_back(std::move(mapper));
   }
-  ++list->num_mappers;
 }
 
-static bool grpc_proxy_mapper_list_map_name(grpc_proxy_mapper_list* list,
-                                            const char* server_uri,
-                                            const grpc_channel_args* args,
-                                            char** name_to_resolve,
-                                            grpc_channel_args** new_args) {
-  for (size_t i = 0; i < list->num_mappers; ++i) {
-    if (grpc_proxy_mapper_map_name(list->list[i], server_uri, args,
-                                   name_to_resolve, new_args)) {
+bool ProxyMapperRegistry::MapName(const char* server_uri,
+                                  const grpc_channel_args* args,
+                                  char** name_to_resolve,
+                                  grpc_channel_args** new_args) {
+  Init();
+  for (const auto& mapper : *g_proxy_mapper_list) {
+    if (mapper->MapName(server_uri, args, name_to_resolve, new_args)) {
       return true;
     }
   }
   return false;
 }
 
-static bool grpc_proxy_mapper_list_map_address(
-    grpc_proxy_mapper_list* list, const grpc_resolved_address* address,
-    const grpc_channel_args* args, grpc_resolved_address** new_address,
-    grpc_channel_args** new_args) {
-  for (size_t i = 0; i < list->num_mappers; ++i) {
-    if (grpc_proxy_mapper_map_address(list->list[i], address, args, new_address,
-                                      new_args)) {
+bool ProxyMapperRegistry::MapAddress(const grpc_resolved_address& address,
+                                     const grpc_channel_args* args,
+                                     grpc_resolved_address** new_address,
+                                     grpc_channel_args** new_args) {
+  Init();
+  for (const auto& mapper : *g_proxy_mapper_list) {
+    if (mapper->MapAddress(address, args, new_address, new_args)) {
       return true;
     }
   }
   return false;
 }
 
-static void grpc_proxy_mapper_list_destroy(grpc_proxy_mapper_list* list) {
-  for (size_t i = 0; i < list->num_mappers; ++i) {
-    grpc_proxy_mapper_destroy(list->list[i]);
-  }
-  gpr_free(list->list);
-  // Clean up in case we re-initialze later.
-  // TODO(ctiller): This should ideally live in
-  // grpc_proxy_mapper_registry_init().  However, if we did this there,
-  // then we would do it AFTER we start registering proxy mappers from
-  // third-party plugins, so they'd never show up (and would leak memory).
-  // We probably need some sort of dependency system for plugins to fix
-  // this.
-  memset(list, 0, sizeof(*list));
-}
-
-//
-// plugin
-//
-
-static grpc_proxy_mapper_list g_proxy_mapper_list;
-
-void grpc_proxy_mapper_registry_init() {}
-
-void grpc_proxy_mapper_registry_shutdown() {
-  grpc_proxy_mapper_list_destroy(&g_proxy_mapper_list);
-}
-
-void grpc_proxy_mapper_register(bool at_start, grpc_proxy_mapper* mapper) {
-  grpc_proxy_mapper_list_register(&g_proxy_mapper_list, at_start, mapper);
-}
-
-bool grpc_proxy_mappers_map_name(const char* server_uri,
-                                 const grpc_channel_args* args,
-                                 char** name_to_resolve,
-                                 grpc_channel_args** new_args) {
-  return grpc_proxy_mapper_list_map_name(&g_proxy_mapper_list, server_uri, args,
-                                         name_to_resolve, new_args);
-}
-bool grpc_proxy_mappers_map_address(const grpc_resolved_address* address,
-                                    const grpc_channel_args* args,
-                                    grpc_resolved_address** new_address,
-                                    grpc_channel_args** new_args) {
-  return grpc_proxy_mapper_list_map_address(&g_proxy_mapper_list, address, args,
-                                            new_address, new_args);
-}
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/proxy_mapper_registry.h

@@ -23,22 +23,28 @@
 
 #include "src/core/ext/filters/client_channel/proxy_mapper.h"
 
-void grpc_proxy_mapper_registry_init();
-void grpc_proxy_mapper_registry_shutdown();
-
-/// Registers a new proxy mapper.  Takes ownership.
-/// If \a at_start is true, the new mapper will be at the beginning of
-/// the list.  Otherwise, it will be added to the end.
-void grpc_proxy_mapper_register(bool at_start, grpc_proxy_mapper* mapper);
-
-bool grpc_proxy_mappers_map_name(const char* server_uri,
-                                 const grpc_channel_args* args,
-                                 char** name_to_resolve,
-                                 grpc_channel_args** new_args);
-
-bool grpc_proxy_mappers_map_address(const grpc_resolved_address* address,
-                                    const grpc_channel_args* args,
-                                    grpc_resolved_address** new_address,
-                                    grpc_channel_args** new_args);
+namespace grpc_core {
+
+class ProxyMapperRegistry {
+ public:
+  static void Init();
+  static void Shutdown();
+
+  /// Registers a new proxy mapper.
+  /// If \a at_start is true, the new mapper will be at the beginning of
+  /// the list.  Otherwise, it will be added to the end.
+  static void Register(bool at_start,
+                       std::unique_ptr<ProxyMapperInterface> mapper);
+
+  static bool MapName(const char* server_uri, const grpc_channel_args* args,
+                      char** name_to_resolve, grpc_channel_args** new_args);
+
+  static bool MapAddress(const grpc_resolved_address& address,
+                         const grpc_channel_args* args,
+                         grpc_resolved_address** new_address,
+                         grpc_channel_args** new_args);
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_REGISTRY_H */

data/src/core/ext/filters/client_channel/resolver.cc

@@ -30,7 +30,8 @@ namespace grpc_core {
 // Resolver
 //
 
-Resolver::Resolver(Combiner* combiner, UniquePtr<ResultHandler> result_handler)
+Resolver::Resolver(Combiner* combiner,
+                   std::unique_ptr<ResultHandler> result_handler)
     : InternallyRefCounted(&grpc_trace_resolver_refcount),
       result_handler_(std::move(result_handler)),
       combiner_(GRPC_COMBINER_REF(combiner, "resolver")) {}

data/src/core/ext/filters/client_channel/resolver.h

@@ -127,7 +127,7 @@ class Resolver : public InternallyRefCounted<Resolver> {
   // API should change to take a RefCountedPtr<>, so that we always take
   // ownership of a new ref.
   explicit Resolver(Combiner* combiner,
-                    UniquePtr<ResultHandler> result_handler);
+                    std::unique_ptr<ResultHandler> result_handler);
 
   /// Shuts down the resolver.
   virtual void ShutdownLocked() = 0;
@@ -137,7 +137,7 @@ class Resolver : public InternallyRefCounted<Resolver> {
   ResultHandler* result_handler() const { return result_handler_.get(); }
 
  private:
-  UniquePtr<ResultHandler> result_handler_;
+  std::unique_ptr<ResultHandler> result_handler_;
   Combiner* combiner_;
 };
 

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -108,7 +108,7 @@ class AresDnsResolver : public Resolver {
   /// retry backoff state
   BackOff backoff_;
   /// currently resolving addresses
-  UniquePtr<ServerAddressList> addresses_;
+  std::unique_ptr<ServerAddressList> addresses_;
   /// currently resolving service config
   char* service_config_json_ = nullptr;
   // has shutdown been initiated

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.cc

@@ -77,7 +77,7 @@ struct grpc_ares_ev_driver {
   /** request object that's using this ev driver */
   grpc_ares_request* request;
   /** Owned by the ev_driver. Creates new GrpcPolledFd's */
-  grpc_core::UniquePtr<grpc_core::GrpcPolledFdFactory> polled_fd_factory;
+  std::unique_ptr<grpc_core::GrpcPolledFdFactory> polled_fd_factory;
   /** query timeout in milliseconds */
   int query_timeout_ms;
   /** alarm to cancel active queries */
@@ -110,7 +110,7 @@ static void grpc_ares_ev_driver_unref(grpc_ares_ev_driver* ev_driver) {
     GRPC_COMBINER_UNREF(ev_driver->combiner, "free ares event driver");
     ares_destroy(ev_driver->channel);
     grpc_ares_complete_request_locked(ev_driver->request);
-    grpc_core::Delete(ev_driver);
+    delete ev_driver;
   }
 }
 
@@ -120,7 +120,7 @@ static void fd_node_destroy_locked(fd_node* fdn) {
   GPR_ASSERT(!fdn->readable_registered);
   GPR_ASSERT(!fdn->writable_registered);
   GPR_ASSERT(fdn->already_shutdown);
-  grpc_core::Delete(fdn->grpc_polled_fd);
+  delete fdn->grpc_polled_fd;
   gpr_free(fdn);
 }
 
@@ -148,7 +148,7 @@ grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
                                               int query_timeout_ms,
                                               grpc_core::Combiner* combiner,
                                               grpc_ares_request* request) {
-  *ev_driver = grpc_core::New<grpc_ares_ev_driver>();
+  *ev_driver = new grpc_ares_ev_driver();
   ares_options opts;
   memset(&opts, 0, sizeof(opts));
   opts.flags |= ARES_FLAG_STAYOPEN;

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h

@@ -95,7 +95,7 @@ class GrpcPolledFdFactory {
   virtual void ConfigureAresChannelLocked(ares_channel channel) = 0;
 };
 
-UniquePtr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Combiner* combiner);
+std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Combiner* combiner);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_libuv.cc

@@ -37,14 +37,14 @@ namespace grpc_core {
 
 void ares_uv_poll_cb(uv_poll_t* handle, int status, int events);
 
-void ares_uv_poll_close_cb(uv_handle_t* handle) { Delete(handle); }
+void ares_uv_poll_close_cb(uv_handle_t* handle) { delete handle; }
 
 class GrpcPolledFdLibuv : public GrpcPolledFd {
  public:
   GrpcPolledFdLibuv(ares_socket_t as, Combiner* combiner)
       : as_(as), combiner_(combiner) {
     gpr_asprintf(&name_, "c-ares socket: %" PRIdPTR, (intptr_t)as);
-    handle_ = New<uv_poll_t>();
+    handle_ = new uv_poll_t();
     uv_poll_init_socket(uv_default_loop(), handle_, as);
     handle_->data = this;
     GRPC_COMBINER_REF(combiner_, "libuv ares event driver");
@@ -81,10 +81,12 @@ class GrpcPolledFdLibuv : public GrpcPolledFd {
     uv_poll_stop(handle_);
     uv_close(reinterpret_cast<uv_handle_t*>(handle_), ares_uv_poll_close_cb);
     if (read_closure_ != nullptr) {
-      GRPC_CLOSURE_SCHED(read_closure_, GRPC_ERROR_CANCELLED);
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, read_closure_,
+                              GRPC_ERROR_CANCELLED);
     }
     if (write_closure_ != nullptr) {
-      GRPC_CLOSURE_SCHED(write_closure_, GRPC_ERROR_CANCELLED);
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, write_closure_,
+                              GRPC_ERROR_CANCELLED);
     }
   }
 
@@ -120,7 +122,7 @@ struct AresUvPollCbArg {
 };
 
 static void ares_uv_poll_cb_locked(void* arg, grpc_error* error) {
-  grpc_core::UniquePtr<AresUvPollCbArg> arg_struct(
+  std::unique_ptr<AresUvPollCbArg> arg_struct(
       reinterpret_cast<AresUvPollCbArg*>(arg));
   uv_poll_t* handle = arg_struct->handle;
   int status = arg_struct->status;
@@ -135,13 +137,13 @@ static void ares_uv_poll_cb_locked(void* arg, grpc_error* error) {
   }
   if (events & UV_READABLE) {
     GPR_ASSERT(polled_fd->read_closure_ != nullptr);
-    GRPC_CLOSURE_SCHED(polled_fd->read_closure_, error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, polled_fd->read_closure_, error);
     polled_fd->read_closure_ = nullptr;
     polled_fd->poll_events_ &= ~UV_READABLE;
   }
   if (events & UV_WRITABLE) {
     GPR_ASSERT(polled_fd->write_closure_ != nullptr);
-    GRPC_CLOSURE_SCHED(polled_fd->write_closure_, error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, polled_fd->write_closure_, error);
     polled_fd->write_closure_ = nullptr;
     polled_fd->poll_events_ &= ~UV_WRITABLE;
   }
@@ -152,7 +154,7 @@ void ares_uv_poll_cb(uv_poll_t* handle, int status, int events) {
   grpc_core::ExecCtx exec_ctx;
   GrpcPolledFdLibuv* polled_fd =
       reinterpret_cast<GrpcPolledFdLibuv*>(handle->data);
-  AresUvPollCbArg* arg = New<AresUvPollCbArg>(handle, status, events);
+  AresUvPollCbArg* arg = new AresUvPollCbArg(handle, status, events);
   polled_fd->combiner_->Run(
       GRPC_CLOSURE_CREATE(ares_uv_poll_cb_locked, arg, nullptr),
       GRPC_ERROR_NONE);
@@ -163,13 +165,14 @@ class GrpcPolledFdFactoryLibuv : public GrpcPolledFdFactory {
   GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as,
                                       grpc_pollset_set* driver_pollset_set,
                                       Combiner* combiner) override {
-    return New<GrpcPolledFdLibuv>(as, combiner);
+    return new GrpcPolledFdLibuv(as, combiner);
   }
 
   void ConfigureAresChannelLocked(ares_channel channel) override {}
 };
 
-UniquePtr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Combiner* combiner) {
+std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
+    Combiner* combiner) {
   return MakeUnique<GrpcPolledFdFactoryLibuv>();
 }