grpc 1.25.0 → 1.26.0.pre1

data/src/core/lib/channel/handshaker.cc

@@ -169,7 +169,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error* error) {
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
     grpc_timer_cancel(&deadline_timer_);
-    GRPC_CLOSURE_SCHED(&on_handshake_done_, error);
+    ExecCtx::Run(DEBUG_LOCATION, &on_handshake_done_, error);
     is_shutdown_ = true;
   } else {
     auto handshaker = handshakers_[index_];

data/src/core/lib/channel/handshaker_registry.cc

@@ -38,21 +38,21 @@ namespace {
 
 class HandshakerFactoryList {
  public:
-  void Register(bool at_start, UniquePtr<HandshakerFactory> factory);
+  void Register(bool at_start, std::unique_ptr<HandshakerFactory> factory);
   void AddHandshakers(const grpc_channel_args* args,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr);
 
  private:
-  InlinedVector<UniquePtr<HandshakerFactory>, 2> factories_;
+  InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_;
 };
 
 HandshakerFactoryList* g_handshaker_factory_lists = nullptr;
 
 }  // namespace
 
-void HandshakerFactoryList::Register(bool at_start,
-                                     UniquePtr<HandshakerFactory> factory) {
+void HandshakerFactoryList::Register(
+    bool at_start, std::unique_ptr<HandshakerFactory> factory) {
   factories_.push_back(std::move(factory));
   if (at_start) {
     auto* end = &factories_[factories_.size() - 1];
@@ -99,7 +99,7 @@ void HandshakerRegistry::Shutdown() {
 
 void HandshakerRegistry::RegisterHandshakerFactory(
     bool at_start, HandshakerType handshaker_type,
-    UniquePtr<HandshakerFactory> factory) {
+    std::unique_ptr<HandshakerFactory> factory) {
   GPR_ASSERT(g_handshaker_factory_lists != nullptr);
   auto& factory_list = g_handshaker_factory_lists[handshaker_type];
   factory_list.Register(at_start, std::move(factory));

data/src/core/lib/channel/handshaker_registry.h

@@ -38,9 +38,9 @@ class HandshakerRegistry {
   /// Registers a new handshaker factory.  Takes ownership.
   /// If \a at_start is true, the new handshaker will be at the beginning of
   /// the list.  Otherwise, it will be added to the end.
-  static void RegisterHandshakerFactory(bool at_start,
-                                        HandshakerType handshaker_type,
-                                        UniquePtr<HandshakerFactory> factory);
+  static void RegisterHandshakerFactory(
+      bool at_start, HandshakerType handshaker_type,
+      std::unique_ptr<HandshakerFactory> factory);
   static void AddHandshakers(HandshakerType handshaker_type,
                              const grpc_channel_args* args,
                              grpc_pollset_set* interested_parties,

data/src/core/lib/compression/message_compress.cc

@@ -80,11 +80,12 @@ error:
   return 0;
 }
 
-static void* zalloc_gpr(void* opaque, unsigned int items, unsigned int size) {
+static void* zalloc_gpr(void* /*opaque*/, unsigned int items,
+                        unsigned int size) {
   return gpr_malloc(items * size);
 }
 
-static void zfree_gpr(void* opaque, void* address) { gpr_free(address); }
+static void zfree_gpr(void* /*opaque*/, void* address) { gpr_free(address); }
 
 static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
                          int gzip) {

data/src/core/lib/compression/stream_compression_identity.cc

@@ -47,12 +47,10 @@ static void grpc_stream_compression_pass_through(grpc_slice_buffer* in,
   }
 }
 
-static bool grpc_stream_compress_identity(grpc_stream_compression_context* ctx,
-                                          grpc_slice_buffer* in,
-                                          grpc_slice_buffer* out,
-                                          size_t* output_size,
-                                          size_t max_output_size,
-                                          grpc_stream_compression_flush flush) {
+static bool grpc_stream_compress_identity(
+    grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
+    grpc_slice_buffer* out, size_t* output_size, size_t max_output_size,
+    grpc_stream_compression_flush /*flush*/) {
   if (ctx == nullptr) {
     return false;
   }
@@ -84,7 +82,7 @@ grpc_stream_compression_context_create_identity(
 }
 
 static void grpc_stream_compression_context_destroy_identity(
-    grpc_stream_compression_context* ctx) {
+    grpc_stream_compression_context* /*ctx*/) {
   return;
 }
 

data/src/core/lib/gpr/alloc.cc

@@ -25,36 +25,11 @@
 #include <string.h>
 #include "src/core/lib/profiling/timers.h"
 
-static void* zalloc_with_calloc(size_t sz) { return calloc(sz, 1); }
-
-static void* zalloc_with_gpr_malloc(size_t sz) {
-  void* p = gpr_malloc(sz);
-  memset(p, 0, sz);
-  return p;
-}
-
-static gpr_allocation_functions g_alloc_functions = {malloc, zalloc_with_calloc,
-                                                     realloc, free};
-
-gpr_allocation_functions gpr_get_allocation_functions() {
-  return g_alloc_functions;
-}
-
-void gpr_set_allocation_functions(gpr_allocation_functions functions) {
-  GPR_ASSERT(functions.malloc_fn != nullptr);
-  GPR_ASSERT(functions.realloc_fn != nullptr);
-  GPR_ASSERT(functions.free_fn != nullptr);
-  if (functions.zalloc_fn == nullptr) {
-    functions.zalloc_fn = zalloc_with_gpr_malloc;
-  }
-  g_alloc_functions = functions;
-}
-
 void* gpr_malloc(size_t size) {
   GPR_TIMER_SCOPE("gpr_malloc", 0);
   void* p;
   if (size == 0) return nullptr;
-  p = g_alloc_functions.malloc_fn(size);
+  p = malloc(size);
   if (!p) {
     abort();
   }
@@ -65,7 +40,7 @@ void* gpr_zalloc(size_t size) {
   GPR_TIMER_SCOPE("gpr_zalloc", 0);
   void* p;
   if (size == 0) return nullptr;
-  p = g_alloc_functions.zalloc_fn(size);
+  p = calloc(size, 1);
   if (!p) {
     abort();
   }
@@ -74,13 +49,13 @@ void* gpr_zalloc(size_t size) {
 
 void gpr_free(void* p) {
   GPR_TIMER_SCOPE("gpr_free", 0);
-  g_alloc_functions.free_fn(p);
+  free(p);
 }
 
 void* gpr_realloc(void* p, size_t size) {
   GPR_TIMER_SCOPE("gpr_realloc", 0);
   if ((size == 0) && (p == nullptr)) return nullptr;
-  p = g_alloc_functions.realloc_fn(p, size);
+  p = realloc(p, size);
   if (!p) {
     abort();
   }

data/src/core/lib/gpr/cpu_linux.cc

@@ -72,7 +72,7 @@ unsigned gpr_cpu_current_cpu(void) {
     return 0;
   }
   if (static_cast<unsigned>(cpu) >= gpr_cpu_num_cores()) {
-    gpr_log(GPR_ERROR, "Cannot handle hot-plugged CPUs");
+    gpr_log(GPR_DEBUG, "Cannot handle hot-plugged CPUs");
     return 0;
   }
   return static_cast<unsigned>(cpu);

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

@@ -172,15 +172,15 @@ void Fork::GlobalInit() {
                            MemoryOrder::RELAXED);
   }
   if (support_enabled_.Load(MemoryOrder::RELAXED)) {
-    exec_ctx_state_ = grpc_core::New<internal::ExecCtxState>();
-    thread_state_ = grpc_core::New<internal::ThreadState>();
+    exec_ctx_state_ = new internal::ExecCtxState();
+    thread_state_ = new internal::ThreadState();
   }
 }
 
 void Fork::GlobalShutdown() {
   if (support_enabled_.Load(MemoryOrder::RELAXED)) {
-    grpc_core::Delete(exec_ctx_state_);
-    grpc_core::Delete(thread_state_);
+    delete exec_ctx_state_;
+    delete thread_state_;
   }
 }
 

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

@@ -56,8 +56,8 @@ void SetGlobalConfigEnvErrorFunction(GlobalConfigEnvErrorFunctionType func) {
   g_global_config_env_error_func = func;
 }
 
-UniquePtr<char> GlobalConfigEnv::GetValue() {
-  return UniquePtr<char>(gpr_getenv(GetName()));
+grpc_core::UniquePtr<char> GlobalConfigEnv::GetValue() {
+  return grpc_core::UniquePtr<char>(gpr_getenv(GetName()));
 }
 
 void GlobalConfigEnv::SetValue(const char* value) {
@@ -78,7 +78,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvBool>::value,
               "GlobalConfigEnvBool needs to be trivially destructible.");
 
 bool GlobalConfigEnvBool::Get() {
-  UniquePtr<char> str = GetValue();
+  grpc_core::UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -99,7 +99,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvInt32>::value,
               "GlobalConfigEnvInt32 needs to be trivially destructible.");
 
 int32_t GlobalConfigEnvInt32::Get() {
-  UniquePtr<char> str = GetValue();
+  grpc_core::UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -122,10 +122,10 @@ void GlobalConfigEnvInt32::Set(int32_t value) {
 static_assert(std::is_trivially_destructible<GlobalConfigEnvString>::value,
               "GlobalConfigEnvString needs to be trivially destructible.");
 
-UniquePtr<char> GlobalConfigEnvString::Get() {
-  UniquePtr<char> str = GetValue();
+grpc_core::UniquePtr<char> GlobalConfigEnvString::Get() {
+  grpc_core::UniquePtr<char> str = GetValue();
   if (str == nullptr) {
-    return UniquePtr<char>(gpr_strdup(default_value_));
+    return grpc_core::UniquePtr<char>(gpr_strdup(default_value_));
   }
   return str;
 }

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

@@ -43,7 +43,7 @@ class GlobalConfigEnv {
 
  public:
   // Returns the value of `name` variable.
-  UniquePtr<char> GetValue();
+  grpc_core::UniquePtr<char> GetValue();
 
   // Sets the value of `name` variable.
   void SetValue(const char* value);
@@ -87,7 +87,7 @@ class GlobalConfigEnvString : public GlobalConfigEnv {
   constexpr GlobalConfigEnvString(char* name, const char* default_value)
       : GlobalConfigEnv(name), default_value_(default_value) {}
 
-  UniquePtr<char> Get();
+  grpc_core::UniquePtr<char> Get();
   void Set(const char* value);
 
  private:

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

@@ -30,7 +30,7 @@
 #include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
-int JoinHostPort(UniquePtr<char>* out, const char* host, int port) {
+int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port) {
   char* tmp;
   int ret;
   if (host[0] != '[' && strchr(host, ':') != nullptr) {
@@ -57,7 +57,7 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
     }
     if (rbracket == name.size() - 1) {
       /* ]<end> */
-      port->clear();
+      *port = StringView();
     } else if (name[rbracket + 1] == ':') {
       /* ]:<port?> */
       *port = name.substr(rbracket + 2, name.size() - rbracket - 2);
@@ -70,7 +70,7 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
     if (host->find(':') == grpc_core::StringView::npos) {
       /* Require all bracketed hosts to contain a colon, because a hostname or
          IPv4 address should never use brackets. */
-      host->clear();
+      *host = StringView();
       return false;
     }
   } else {
@@ -84,7 +84,7 @@ bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
     } else {
       /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
       *host = name;
-      port->clear();
+      *port = StringView();
     }
   }
   return true;
@@ -96,8 +96,8 @@ bool SplitHostPort(StringView name, StringView* host, StringView* port) {
   return DoSplitHostPort(name, host, port, &unused);
 }
 
-bool SplitHostPort(StringView name, UniquePtr<char>* host,
-                   UniquePtr<char>* port) {
+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;
@@ -108,9 +108,9 @@ bool SplitHostPort(StringView name, UniquePtr<char>* host,
     // 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 = host_view.dup();
+    *host = StringViewToCString(host_view);
     if (has_port) {
-      *port = port_view.dup();
+      *port = StringViewToCString(port_view);
     }
   }
   return ret;

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

@@ -35,7 +35,7 @@ namespace grpc_core {
    (excluding the final '\0'), and *out points to a string.
 
    In the unlikely event of an error, returns -1 and sets *out to NULL. */
-int JoinHostPort(UniquePtr<char>* out, const char* host, int port);
+int JoinHostPort(grpc_core::UniquePtr<char>* out, const char* host, int port);
 
 /** Given a name in the form "host:port" or "[ho:st]:port", split into hostname
    and port number.
@@ -51,8 +51,8 @@ int JoinHostPort(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, UniquePtr<char>* host,
-                   UniquePtr<char>* port);
+bool SplitHostPort(StringView name, grpc_core::UniquePtr<char>* host,
+                   grpc_core::UniquePtr<char>* port);
 
 }  // namespace grpc_core
 

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

@@ -26,8 +26,19 @@
 
 #include "src/core/lib/gprpp/memory.h"
 
+#if GRPC_USE_ABSL
+#include "absl/container/inlined_vector.h"
+#endif
+
 namespace grpc_core {
 
+#if GRPC_USE_ABSL
+
+template <typename T, size_t N, typename A = std::allocator<T>>
+using InlinedVector = absl::InlinedVector<T, N, A>;
+
+#else
+
 // NOTE: We eventually want to use absl::InlinedVector here.  However,
 // there are currently build problems that prevent us from using absl.
 // In the interim, we define a custom implementation as a place-holder,
@@ -228,6 +239,8 @@ class InlinedVector {
   size_t capacity_;
 };
 
+#endif
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_INLINED_VECTOR_H */

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

@@ -23,26 +23,19 @@
 
 #include <string.h>
 
-#include <algorithm>
-#include <functional>
-#include <iterator>
 #include <map>
 
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
 
-template <class Key, class T, class Compare = std::less<Key>>
-using Map = std::map<Key, T, Compare, Allocator<std::pair<const Key, T>>>;
-
 struct StringLess {
   bool operator()(const char* a, const char* b) const {
     return strcmp(a, b) < 0;
   }
-  bool operator()(const UniquePtr<char>& a, const UniquePtr<char>& b) const {
+  bool operator()(const grpc_core::UniquePtr<char>& a,
+                  const grpc_core::UniquePtr<char>& b) const {
     return strcmp(a.get(), b.get()) < 0;
   }
   bool operator()(const StringView& a, const StringView& b) const {

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

@@ -30,110 +30,24 @@
 
 namespace grpc_core {
 
-// Alternative to new, to ensure memory allocation being wrapped to gpr_malloc
-template <typename T, typename... Args>
-inline T* New(Args&&... args) {
-  void* p = gpr_malloc(sizeof(T));
-  return new (p) T(std::forward<Args>(args)...);
-}
-
-// Gets the base pointer of any class, in case of multiple inheritance.
-// Used by Delete and friends.
-template <typename T, bool isPolymorphic>
-struct BasePointerGetter {
-  static void* get(T* p) { return p; }
-};
-
-template <typename T>
-struct BasePointerGetter<T, true> {
-  static void* get(T* p) { return dynamic_cast<void*>(p); }
-};
-
-// Alternative to delete, to ensure memory allocation being wrapped to gpr_free
-template <typename T>
-inline void Delete(T* p) {
-  if (p == nullptr) return;
-  void* basePtr = BasePointerGetter<T, std::is_polymorphic<T>::value>::get(p);
-  p->~T();
-  gpr_free(basePtr);
-}
-
-class DefaultDelete {
+class DefaultDeleteChar {
  public:
-  template <typename T>
-  void operator()(T* p) {
-    // Delete() checks whether the value is null, but std::unique_ptr<> is
-    // guaranteed not to call the deleter if the pointer is nullptr
-    // (i.e., it already does this check for us), and we don't want to
-    // do the check twice.  So, instead of calling Delete() here, we
-    // manually call the object's dtor and free it.
-    void* basePtr = BasePointerGetter<T, std::is_polymorphic<T>::value>::get(p);
-    p->~T();
-    gpr_free(basePtr);
+  void operator()(char* p) {
+    if (p == nullptr) return;
+    gpr_free(p);
   }
 };
 
-template <typename T, typename Deleter = DefaultDelete>
-using UniquePtr = std::unique_ptr<T, Deleter>;
+// UniquePtr<T> is only allowed for char and UniquePtr<char> is deprecated
+// in favor of std::string. UniquePtr<char> is equivalent std::unique_ptr
+// except that it uses gpr_free for deleter.
+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 UniquePtr<T> MakeUnique(Args&&... args) {
-  return UniquePtr<T>(New<T>(std::forward<Args>(args)...));
-}
-
-// an allocator that uses gpr_malloc/gpr_free
-template <class T>
-class Allocator {
- public:
-  typedef T value_type;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef std::size_t size_type;
-  typedef std::ptrdiff_t difference_type;
-  typedef std::false_type propagate_on_container_move_assignment;
-  template <class U>
-  struct rebind {
-    typedef Allocator<U> other;
-  };
-  typedef std::true_type is_always_equal;
-
-  Allocator() = default;
-
-  template <class U>
-  Allocator(const Allocator<U>&) {}
-
-  pointer address(reference x) const { return &x; }
-  const_pointer address(const_reference x) const { return &x; }
-  pointer allocate(std::size_t n,
-                   std::allocator<void>::const_pointer /*hint*/ = nullptr) {
-    return static_cast<pointer>(gpr_malloc(n * sizeof(T)));
-  }
-  void deallocate(T* p, std::size_t /* n */) { gpr_free(p); }
-  size_t max_size() const {
-    return std::numeric_limits<size_type>::max() / sizeof(value_type);
-  }
-  void construct(pointer p, const_reference val) { new ((void*)p) T(val); }
-  template <class U, class... Args>
-  void construct(U* p, Args&&... args) {
-    ::new ((void*)p) U(std::forward<Args>(args)...);
-  }
-  void destroy(pointer p) { p->~T(); }
-  template <class U>
-  void destroy(U* p) {
-    p->~U();
-  }
-};
-
-template <class T, class U>
-bool operator==(Allocator<T> const&, Allocator<U> const&) noexcept {
-  return true;
-}
-
-template <class T, class U>
-bool operator!=(Allocator<T> const& /*x*/, Allocator<U> const& /*y*/) noexcept {
-  return false;
+inline std::unique_ptr<T> MakeUnique(Args&&... args) {
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
 }  // namespace grpc_core