grpc 1.9.1 → 1.10.0.pre1

data/{include/grpc/support → src/core/lib/avl}/avl.h

@@ -16,31 +16,27 @@
  *
  */
 
-#ifndef GRPC_SUPPORT_AVL_H
-#define GRPC_SUPPORT_AVL_H
+#ifndef GRPC_CORE_LIB_AVL_AVL_H
+#define GRPC_CORE_LIB_AVL_AVL_H
 
 #include <grpc/support/sync.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /** internal node of an AVL tree */
-typedef struct gpr_avl_node {
+typedef struct grpc_avl_node {
   gpr_refcount refs;
   void* key;
   void* value;
-  struct gpr_avl_node* left;
-  struct gpr_avl_node* right;
+  struct grpc_avl_node* left;
+  struct grpc_avl_node* right;
   long height;
-} gpr_avl_node;
+} grpc_avl_node;
 
 /** vtable for the AVL tree
- * The optional user_data is propagated from the top level gpr_avl_XXX API.
+ * The optional user_data is propagated from the top level grpc_avl_XXX API.
  * From the same API call, multiple vtable functions may be called multiple
  * times.
  */
-typedef struct gpr_avl_vtable {
+typedef struct grpc_avl_vtable {
   /** destroy a key */
   void (*destroy_key)(void* key, void* user_data);
   /** copy a key, returning new value */
@@ -52,51 +48,45 @@ typedef struct gpr_avl_vtable {
   void (*destroy_value)(void* value, void* user_data);
   /** copy a value */
   void* (*copy_value)(void* value, void* user_data);
-} gpr_avl_vtable;
+} grpc_avl_vtable;
 
 /** "pointer" to an AVL tree - this is a reference
-    counted object - use gpr_avl_ref to add a reference,
-    gpr_avl_unref when done with a reference */
-typedef struct gpr_avl {
-  const gpr_avl_vtable* vtable;
-  gpr_avl_node* root;
-} gpr_avl;
+    counted object - use grpc_avl_ref to add a reference,
+    grpc_avl_unref when done with a reference */
+typedef struct grpc_avl {
+  const grpc_avl_vtable* vtable;
+  grpc_avl_node* root;
+} grpc_avl;
 
 /** Create an immutable AVL tree. */
-GPRAPI gpr_avl gpr_avl_create(const gpr_avl_vtable* vtable);
+grpc_avl grpc_avl_create(const grpc_avl_vtable* vtable);
 /** Add a reference to an existing tree - returns
     the tree as a convenience. The optional user_data will be passed to vtable
     functions. */
-GPRAPI gpr_avl gpr_avl_ref(gpr_avl avl, void* user_data);
+grpc_avl grpc_avl_ref(grpc_avl avl, void* user_data);
 /** Remove a reference to a tree - destroying it if there
     are no references left. The optional user_data will be passed to vtable
     functions. */
-GPRAPI void gpr_avl_unref(gpr_avl avl, void* user_data);
+void grpc_avl_unref(grpc_avl avl, void* user_data);
 /** Return a new tree with (key, value) added to avl.
     implicitly unrefs avl to allow easy chaining.
     if key exists in avl, the new tree's key entry updated
     (i.e. a duplicate is not created). The optional user_data will be passed to
     vtable functions. */
-GPRAPI gpr_avl gpr_avl_add(gpr_avl avl, void* key, void* value,
-                           void* user_data);
+grpc_avl grpc_avl_add(grpc_avl avl, void* key, void* value, void* user_data);
 /** Return a new tree with key deleted
     implicitly unrefs avl to allow easy chaining. The optional user_data will be
     passed to vtable functions. */
-GPRAPI gpr_avl gpr_avl_remove(gpr_avl avl, void* key, void* user_data);
+grpc_avl grpc_avl_remove(grpc_avl avl, void* key, void* user_data);
 /** Lookup key, and return the associated value.
     Does not mutate avl.
     Returns NULL if key is not found. The optional user_data will be passed to
     vtable functions.*/
-GPRAPI void* gpr_avl_get(gpr_avl avl, void* key, void* user_data);
+void* grpc_avl_get(grpc_avl avl, void* key, void* user_data);
 /** Return 1 if avl contains key, 0 otherwise; if it has the key, sets *value to
-    its value. THe optional user_data will be passed to vtable functions. */
-GPRAPI int gpr_avl_maybe_get(gpr_avl avl, void* key, void** value,
-                             void* user_data);
+    its value. The optional user_data will be passed to vtable functions. */
+int grpc_avl_maybe_get(grpc_avl avl, void* key, void** value, void* user_data);
 /** Return 1 if avl is empty, 0 otherwise */
-GPRAPI int gpr_avl_is_empty(gpr_avl avl);
-
-#ifdef __cplusplus
-}
-#endif
+int grpc_avl_is_empty(grpc_avl avl);
 
-#endif /* GRPC_SUPPORT_AVL_H */
+#endif /* GRPC_CORE_LIB_AVL_AVL_H */

data/src/core/lib/backoff/backoff.cc

@@ -20,7 +20,7 @@
 
 #include <algorithm>
 
-#include <grpc/support/useful.h>
+#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
 
@@ -55,13 +55,14 @@ grpc_millis BackOff::NextAttemptTime() {
     initial_ = false;
     return current_backoff_ + grpc_core::ExecCtx::Get()->Now();
   }
-  current_backoff_ =
-      (grpc_millis)(std::min(current_backoff_ * options_.multiplier(),
-                             (double)options_.max_backoff()));
+  current_backoff_ = static_cast<grpc_millis>(
+      std::min(current_backoff_ * options_.multiplier(),
+               static_cast<double>(options_.max_backoff())));
   const double jitter = generate_uniform_random_number_between(
       &rng_state_, -options_.jitter() * current_backoff_,
       options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout = (grpc_millis)(current_backoff_ + jitter);
+  const grpc_millis next_timeout =
+      static_cast<grpc_millis>(current_backoff_ + jitter);
   return next_timeout + grpc_core::ExecCtx::Get()->Now();
 }
 

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

@@ -26,10 +26,10 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 
 static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
@@ -87,13 +87,14 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
   }
   // Create result.
   grpc_channel_args* dst =
-      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
   dst->num_args = num_args_to_copy + num_to_add;
   if (dst->num_args == 0) {
     dst->args = nullptr;
     return dst;
   }
-  dst->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
+  dst->args =
+      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * dst->num_args));
   // Copy args from src that are not being removed.
   size_t dst_idx = 0;
   if (src != nullptr) {
@@ -118,7 +119,8 @@ grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
 grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
                                            const grpc_channel_args* b) {
   const size_t max_out = (a->num_args + b->num_args);
-  grpc_arg* uniques = (grpc_arg*)gpr_malloc(sizeof(*uniques) * max_out);
+  grpc_arg* uniques =
+      static_cast<grpc_arg*>(gpr_malloc(sizeof(*uniques) * max_out));
   for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i];
 
   size_t uniques_idx = a->num_args;
@@ -161,15 +163,16 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
 /* stabilizing comparison function: since channel_args ordering matters for
  * keys with the same name, we need to preserve that ordering */
 static int cmp_key_stable(const void* ap, const void* bp) {
-  const grpc_arg* const* a = (const grpc_arg* const*)ap;
-  const grpc_arg* const* b = (const grpc_arg* const*)bp;
+  const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
+  const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);
   int c = strcmp((*a)->key, (*b)->key);
   if (c == 0) c = GPR_ICMP(*a, *b);
   return c;
 }
 
 grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
-  grpc_arg** args = (grpc_arg**)gpr_malloc(sizeof(grpc_arg*) * a->num_args);
+  grpc_arg** args =
+      static_cast<grpc_arg**>(gpr_malloc(sizeof(grpc_arg*) * a->num_args));
   for (size_t i = 0; i < a->num_args; i++) {
     args[i] = &a->args[i];
   }
@@ -177,9 +180,9 @@ grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
     qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
 
   grpc_channel_args* b =
-      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
   b->num_args = a->num_args;
-  b->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * b->num_args);
+  b->args = static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * b->num_args));
   for (size_t i = 0; i < a->num_args; i++) {
     b->args[i] = copy_arg(args[i]);
   }
@@ -215,28 +218,13 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
-      return (grpc_compression_algorithm)a->args[i].value.integer;
+      return static_cast<grpc_compression_algorithm>(a->args[i].value.integer);
       break;
     }
   }
   return GRPC_COMPRESS_NONE;
 }
 
-grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a) {
-  size_t i;
-  if (a == nullptr) return GRPC_STREAM_COMPRESS_NONE;
-  for (i = 0; i < a->num_args; ++i) {
-    if (a->args[i].type == GRPC_ARG_INTEGER &&
-        !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
-                a->args[i].key)) {
-      return (grpc_stream_compression_algorithm)a->args[i].value.integer;
-      break;
-    }
-  }
-  return GRPC_STREAM_COMPRESS_NONE;
-}
-
 grpc_channel_args* grpc_channel_args_set_compression_algorithm(
     grpc_channel_args* a, grpc_compression_algorithm algorithm) {
   GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
@@ -247,16 +235,6 @@ grpc_channel_args* grpc_channel_args_set_compression_algorithm(
   return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
 
-grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
-    grpc_channel_args* a, grpc_stream_compression_algorithm algorithm) {
-  GPR_ASSERT(algorithm < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
-  grpc_arg tmp;
-  tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
-  tmp.value.integer = algorithm;
-  return grpc_channel_args_copy_and_add(a, &tmp, 1);
-}
-
 /** Returns 1 if the argument for compression algorithm's enabled states bitset
  * was found in \a a, returning the arg's value in \a states. Otherwise, returns
  * 0. */
@@ -277,26 +255,6 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
   return 0; /* GPR_FALSE */
 }
 
-/** Returns 1 if the argument for compression algorithm's enabled states bitset
- * was found in \a a, returning the arg's value in \a states. Otherwise, returns
- * 0. */
-static int find_stream_compression_algorithm_states_bitset(
-    const grpc_channel_args* a, int** states_arg) {
-  if (a != nullptr) {
-    size_t i;
-    for (i = 0; i < a->num_args; ++i) {
-      if (a->args[i].type == GRPC_ARG_INTEGER &&
-          !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
-                  a->args[i].key)) {
-        *states_arg = &a->args[i].value.integer;
-        **states_arg |= 0x1; /* forcefully enable support for no compression */
-        return 1;
-      }
-    }
-  }
-  return 0; /* GPR_FALSE */
-}
-
 grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
     grpc_channel_args** a, grpc_compression_algorithm algorithm, int state) {
   int* states_arg = nullptr;
@@ -337,69 +295,16 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
   return result;
 }
 
-grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_stream_compression_algorithm algorithm,
-    int state) {
-  int* states_arg = nullptr;
-  grpc_channel_args* result = *a;
-  const int states_arg_found =
-      find_stream_compression_algorithm_states_bitset(*a, &states_arg);
-
-  if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
-      state == 0) {
-    const char* algo_name = nullptr;
-    GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
-               0);
-    gpr_log(GPR_ERROR,
-            "Tried to disable default stream compression algorithm '%s'. The "
-            "operation has been ignored.",
-            algo_name);
-  } else if (states_arg_found) {
-    if (state != 0) {
-      GPR_BITSET((unsigned*)states_arg, algorithm);
-    } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)states_arg, algorithm);
-    }
-  } else {
-    /* create a new arg */
-    grpc_arg tmp;
-    tmp.type = GRPC_ARG_INTEGER;
-    tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
-    /* all enabled by default */
-    tmp.value.integer = (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
-    if (state != 0) {
-      GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
-    } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
-    }
-    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(*a);
-    *a = result;
-  }
-  return result;
-}
-
 uint32_t grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args* a) {
   int* states_arg;
   if (find_compression_algorithm_states_bitset(a, &states_arg)) {
-    return (uint32_t)*states_arg;
+    return static_cast<uint32_t>(*states_arg);
   } else {
     return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; /* All algs. enabled */
   }
 }
 
-uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
-    const grpc_channel_args* a) {
-  int* states_arg;
-  if (find_stream_compression_algorithm_states_bitset(a, &states_arg)) {
-    return (uint32_t)*states_arg;
-  } else {
-    return (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) -
-           1; /* All algs. enabled */
-  }
-}
-
 grpc_channel_args* grpc_channel_args_set_socket_mutator(
     grpc_channel_args* a, grpc_socket_mutator* mutator) {
   grpc_arg tmp = grpc_socket_mutator_to_arg(mutator);
@@ -449,6 +354,15 @@ int grpc_channel_arg_get_integer(const grpc_arg* arg,
   return arg->value.integer;
 }
 
+char* grpc_channel_arg_get_string(const grpc_arg* arg) {
+  if (arg == nullptr) return nullptr;
+  if (arg->type != GRPC_ARG_STRING) {
+    gpr_log(GPR_ERROR, "%s ignored: it must be an string", arg->key);
+    return nullptr;
+  }
+  return arg->value.string;
+}
+
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
   if (arg == nullptr) return default_value;
   if (arg->type != GRPC_ARG_INTEGER) {

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

@@ -59,24 +59,12 @@ void grpc_channel_args_destroy(grpc_channel_args* a);
 grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
     const grpc_channel_args* a);
 
-/** Returns the stream compression algorithm set in \a a. */
-grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a);
-
 /** Returns a channel arg instance with compression enabled. If \a a is
  * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
  * for the channel. */
 grpc_channel_args* grpc_channel_args_set_compression_algorithm(
     grpc_channel_args* a, grpc_compression_algorithm algorithm);
 
-/** Returns a channel arg instance with stream compression enabled. If \a a is
- * non-NULL, its args are copied. N.B. GRPC_STREAM_COMPRESS_NONE disables
- * stream compression for the channel. If a value other than
- * GRPC_STREAM_COMPRESS_NONE is set, it takes precedence over message-wise
- * compression algorithms. */
-grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
-    grpc_channel_args* a, grpc_stream_compression_algorithm algorithm);
-
 /** Sets the support for the given compression algorithm. By default, all
  * compression algorithms are enabled. It's an error to disable an algorithm set
  * by grpc_channel_args_set_compression_algorithm.
@@ -87,17 +75,6 @@ grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
 grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
     grpc_channel_args** a, grpc_compression_algorithm algorithm, int enabled);
 
-/** Sets the support for the given stream compression algorithm. By default, all
- * stream compression algorithms are enabled. It's an error to disable an
- * algorithm set by grpc_channel_args_set_stream_compression_algorithm.
- *
- * Returns an instance with the updated algorithm states. The \a a pointer is
- * modified to point to the returned instance (which may be different from the
- * input value of \a a). */
-grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_stream_compression_algorithm algorithm,
-    int enabled);
-
 /** Returns the bitset representing the support state (true for enabled, false
  * for disabled) for compression algorithms.
  *
@@ -106,14 +83,6 @@ grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
 uint32_t grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args* a);
 
-/** Returns the bitset representing the support state (true for enabled, false
- * for disabled) for stream compression algorithms.
- *
- * The i-th bit of the returned bitset corresponds to the i-th entry in the
- * grpc_stream_compression_algorithm enum. */
-uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
-    const grpc_channel_args* a);
-
 int grpc_channel_args_compare(const grpc_channel_args* a,
                               const grpc_channel_args* b);
 
@@ -140,6 +109,11 @@ typedef struct grpc_integer_options {
 int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options);
 
+/** Returns the value of \a arg if \a arg is of type GRPC_ARG_STRING.
+    Otherwise, emits a warning log, and returns nullptr.
+    If arg is nullptr, returns nullptr, and does not emit a warning. */
+char* grpc_channel_arg_get_string(const grpc_arg* arg);
+
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value);
 
 // Helpers for creating channel args.

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

@@ -104,8 +104,9 @@ grpc_error* grpc_channel_stack_init(
   GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg,
                        name);
   elems = CHANNEL_ELEMS_FROM_STACK(stack);
-  user_data = ((char*)elems) + ROUND_UP_TO_ALIGNMENT_SIZE(
-                                   filter_count * sizeof(grpc_channel_element));
+  user_data =
+      (reinterpret_cast<char*>(elems)) +
+      ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_channel_element));
 
   /* init per-filter data */
   grpc_error* first_error = GRPC_ERROR_NONE;
@@ -162,7 +163,7 @@ grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
   GRPC_STREAM_REF_INIT(&elem_args->call_stack->refcount, initial_refs, destroy,
                        destroy_arg, "CALL_STACK");
   call_elems = CALL_ELEMS_FROM_STACK(elem_args->call_stack);
-  user_data = ((char*)call_elems) +
+  user_data = (reinterpret_cast<char*>(call_elems)) +
               ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
@@ -194,7 +195,7 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
   size_t i;
 
   call_elems = CALL_ELEMS_FROM_STACK(call_stack);
-  user_data = ((char*)call_elems) +
+  user_data = (reinterpret_cast<char*>(call_elems)) +
               ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
@@ -243,11 +244,13 @@ void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) {
 
 grpc_channel_stack* grpc_channel_stack_from_top_element(
     grpc_channel_element* elem) {
-  return (grpc_channel_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
-      sizeof(grpc_channel_stack)));
+  return reinterpret_cast<grpc_channel_stack*>(
+      reinterpret_cast<char*>(elem) -
+      ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)));
 }
 
 grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
-  return (grpc_call_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
-      sizeof(grpc_call_stack)));
+  return reinterpret_cast<grpc_call_stack*>(
+      reinterpret_cast<char*>(elem) -
+      ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)));
 }