grpc 1.7.3 → 1.8.0

data/src/core/ext/transport/chttp2/transport/{stream_lists.c → stream_lists.cc}

@@ -16,11 +16,12 @@
  *
  */
 
+#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 
 #include <grpc/support/log.h>
 
-static char *stream_list_id_string(grpc_chttp2_stream_list_id id) {
+static const char* stream_list_id_string(grpc_chttp2_stream_list_id id) {
   switch (id) {
     case GRPC_CHTTP2_LIST_WRITABLE:
       return "writable";
@@ -38,41 +39,40 @@ static char *stream_list_id_string(grpc_chttp2_stream_list_id id) {
   GPR_UNREACHABLE_CODE(return "unknown");
 }
 
-grpc_tracer_flag grpc_trace_http2_stream_state =
-    GRPC_TRACER_INITIALIZER(false, "http2_stream_state");
+grpc_core::TraceFlag grpc_trace_http2_stream_state(false, "http2_stream_state");
 
 /* core list management */
 
-static bool stream_list_empty(grpc_chttp2_transport *t,
+static bool stream_list_empty(grpc_chttp2_transport* t,
                               grpc_chttp2_stream_list_id id) {
-  return t->lists[id].head == NULL;
+  return t->lists[id].head == nullptr;
 }
 
-static bool stream_list_pop(grpc_chttp2_transport *t,
-                            grpc_chttp2_stream **stream,
+static bool stream_list_pop(grpc_chttp2_transport* t,
+                            grpc_chttp2_stream** stream,
                             grpc_chttp2_stream_list_id id) {
-  grpc_chttp2_stream *s = t->lists[id].head;
+  grpc_chttp2_stream* s = t->lists[id].head;
   if (s) {
-    grpc_chttp2_stream *new_head = s->links[id].next;
+    grpc_chttp2_stream* new_head = s->links[id].next;
     GPR_ASSERT(s->included[id]);
     if (new_head) {
       t->lists[id].head = new_head;
-      new_head->links[id].prev = NULL;
+      new_head->links[id].prev = nullptr;
     } else {
-      t->lists[id].head = NULL;
-      t->lists[id].tail = NULL;
+      t->lists[id].head = nullptr;
+      t->lists[id].tail = nullptr;
     }
     s->included[id] = 0;
   }
   *stream = s;
-  if (s && GRPC_TRACER_ON(grpc_trace_http2_stream_state)) {
+  if (s && grpc_trace_http2_stream_state.enabled()) {
     gpr_log(GPR_DEBUG, "%p[%d][%s]: pop from %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
-  return s != 0;
+  return s != nullptr;
 }
 
-static void stream_list_remove(grpc_chttp2_transport *t, grpc_chttp2_stream *s,
+static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                                grpc_chttp2_stream_list_id id) {
   GPR_ASSERT(s->included[id]);
   s->included[id] = 0;
@@ -87,14 +87,14 @@ static void stream_list_remove(grpc_chttp2_transport *t, grpc_chttp2_stream *s,
   } else {
     t->lists[id].tail = s->links[id].prev;
   }
-  if (GRPC_TRACER_ON(grpc_trace_http2_stream_state)) {
+  if (grpc_trace_http2_stream_state.enabled()) {
     gpr_log(GPR_DEBUG, "%p[%d][%s]: remove from %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
 }
 
-static bool stream_list_maybe_remove(grpc_chttp2_transport *t,
-                                     grpc_chttp2_stream *s,
+static bool stream_list_maybe_remove(grpc_chttp2_transport* t,
+                                     grpc_chttp2_stream* s,
                                      grpc_chttp2_stream_list_id id) {
   if (s->included[id]) {
     stream_list_remove(t, s, id);
@@ -104,13 +104,13 @@ static bool stream_list_maybe_remove(grpc_chttp2_transport *t,
   }
 }
 
-static void stream_list_add_tail(grpc_chttp2_transport *t,
-                                 grpc_chttp2_stream *s,
+static void stream_list_add_tail(grpc_chttp2_transport* t,
+                                 grpc_chttp2_stream* s,
                                  grpc_chttp2_stream_list_id id) {
-  grpc_chttp2_stream *old_tail;
+  grpc_chttp2_stream* old_tail;
   GPR_ASSERT(!s->included[id]);
   old_tail = t->lists[id].tail;
-  s->links[id].next = NULL;
+  s->links[id].next = nullptr;
   s->links[id].prev = old_tail;
   if (old_tail) {
     old_tail->links[id].next = s;
@@ -119,13 +119,13 @@ static void stream_list_add_tail(grpc_chttp2_transport *t,
   }
   t->lists[id].tail = s;
   s->included[id] = 1;
-  if (GRPC_TRACER_ON(grpc_trace_http2_stream_state)) {
+  if (grpc_trace_http2_stream_state.enabled()) {
     gpr_log(GPR_DEBUG, "%p[%d][%s]: add to %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
 }
 
-static bool stream_list_add(grpc_chttp2_transport *t, grpc_chttp2_stream *s,
+static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                             grpc_chttp2_stream_list_id id) {
   if (s->included[id]) {
     return false;
@@ -136,77 +136,77 @@ static bool stream_list_add(grpc_chttp2_transport *t, grpc_chttp2_stream *s,
 
 /* wrappers for specializations */
 
-bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport *t,
-                                          grpc_chttp2_stream *s) {
+bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
+                                          grpc_chttp2_stream* s) {
   GPR_ASSERT(s->id != 0);
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
-bool grpc_chttp2_list_pop_writable_stream(grpc_chttp2_transport *t,
-                                          grpc_chttp2_stream **s) {
+bool grpc_chttp2_list_pop_writable_stream(grpc_chttp2_transport* t,
+                                          grpc_chttp2_stream** s) {
   return stream_list_pop(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
-bool grpc_chttp2_list_remove_writable_stream(grpc_chttp2_transport *t,
-                                             grpc_chttp2_stream *s) {
+bool grpc_chttp2_list_remove_writable_stream(grpc_chttp2_transport* t,
+                                             grpc_chttp2_stream* s) {
   return stream_list_maybe_remove(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
-bool grpc_chttp2_list_add_writing_stream(grpc_chttp2_transport *t,
-                                         grpc_chttp2_stream *s) {
+bool grpc_chttp2_list_add_writing_stream(grpc_chttp2_transport* t,
+                                         grpc_chttp2_stream* s) {
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITING);
 }
 
-bool grpc_chttp2_list_have_writing_streams(grpc_chttp2_transport *t) {
+bool grpc_chttp2_list_have_writing_streams(grpc_chttp2_transport* t) {
   return !stream_list_empty(t, GRPC_CHTTP2_LIST_WRITING);
 }
 
-bool grpc_chttp2_list_pop_writing_stream(grpc_chttp2_transport *t,
-                                         grpc_chttp2_stream **s) {
+bool grpc_chttp2_list_pop_writing_stream(grpc_chttp2_transport* t,
+                                         grpc_chttp2_stream** s) {
   return stream_list_pop(t, s, GRPC_CHTTP2_LIST_WRITING);
 }
 
-void grpc_chttp2_list_add_waiting_for_concurrency(grpc_chttp2_transport *t,
-                                                  grpc_chttp2_stream *s) {
+void grpc_chttp2_list_add_waiting_for_concurrency(grpc_chttp2_transport* t,
+                                                  grpc_chttp2_stream* s) {
   stream_list_add(t, s, GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY);
 }
 
-bool grpc_chttp2_list_pop_waiting_for_concurrency(grpc_chttp2_transport *t,
-                                                  grpc_chttp2_stream **s) {
+bool grpc_chttp2_list_pop_waiting_for_concurrency(grpc_chttp2_transport* t,
+                                                  grpc_chttp2_stream** s) {
   return stream_list_pop(t, s, GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY);
 }
 
-void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport *t,
-                                                     grpc_chttp2_stream *s) {
+void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t,
+                                                     grpc_chttp2_stream* s) {
   stream_list_maybe_remove(t, s, GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY);
 }
 
-void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport *t,
-                                               grpc_chttp2_stream *s) {
+void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t,
+                                               grpc_chttp2_stream* s) {
   stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
-bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport *t,
-                                               grpc_chttp2_stream **s) {
+bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport* t,
+                                               grpc_chttp2_stream** s) {
   return stream_list_pop(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
-void grpc_chttp2_list_remove_stalled_by_transport(grpc_chttp2_transport *t,
-                                                  grpc_chttp2_stream *s) {
+void grpc_chttp2_list_remove_stalled_by_transport(grpc_chttp2_transport* t,
+                                                  grpc_chttp2_stream* s) {
   stream_list_maybe_remove(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
-void grpc_chttp2_list_add_stalled_by_stream(grpc_chttp2_transport *t,
-                                            grpc_chttp2_stream *s) {
+void grpc_chttp2_list_add_stalled_by_stream(grpc_chttp2_transport* t,
+                                            grpc_chttp2_stream* s) {
   stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_STREAM);
 }
 
-bool grpc_chttp2_list_pop_stalled_by_stream(grpc_chttp2_transport *t,
-                                            grpc_chttp2_stream **s) {
+bool grpc_chttp2_list_pop_stalled_by_stream(grpc_chttp2_transport* t,
+                                            grpc_chttp2_stream** s) {
   return stream_list_pop(t, s, GRPC_CHTTP2_LIST_STALLED_BY_STREAM);
 }
 
-bool grpc_chttp2_list_remove_stalled_by_stream(grpc_chttp2_transport *t,
-                                               grpc_chttp2_stream *s) {
+bool grpc_chttp2_list_remove_stalled_by_stream(grpc_chttp2_transport* t,
+                                               grpc_chttp2_stream* s) {
   return stream_list_maybe_remove(t, s, GRPC_CHTTP2_LIST_STALLED_BY_STREAM);
 }

data/src/core/ext/transport/chttp2/transport/{stream_map.c → stream_map.cc}

@@ -24,22 +24,22 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-void grpc_chttp2_stream_map_init(grpc_chttp2_stream_map *map,
+void grpc_chttp2_stream_map_init(grpc_chttp2_stream_map* map,
                                  size_t initial_capacity) {
   GPR_ASSERT(initial_capacity > 1);
-  map->keys = (uint32_t *)gpr_malloc(sizeof(uint32_t) * initial_capacity);
-  map->values = (void **)gpr_malloc(sizeof(void *) * initial_capacity);
+  map->keys = (uint32_t*)gpr_malloc(sizeof(uint32_t) * initial_capacity);
+  map->values = (void**)gpr_malloc(sizeof(void*) * initial_capacity);
   map->count = 0;
   map->free = 0;
   map->capacity = initial_capacity;
 }
 
-void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map *map) {
+void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map* map) {
   gpr_free(map->keys);
   gpr_free(map->values);
 }
 
-static size_t compact(uint32_t *keys, void **values, size_t count) {
+static size_t compact(uint32_t* keys, void** values, size_t count) {
   size_t i, out;
 
   for (i = 0, out = 0; i < count; i++) {
@@ -53,16 +53,16 @@ static size_t compact(uint32_t *keys, void **values, size_t count) {
   return out;
 }
 
-void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
-                                void *value) {
+void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map* map, uint32_t key,
+                                void* value) {
   size_t count = map->count;
   size_t capacity = map->capacity;
-  uint32_t *keys = map->keys;
-  void **values = map->values;
+  uint32_t* keys = map->keys;
+  void** values = map->values;
 
   GPR_ASSERT(count == 0 || keys[count - 1] < key);
   GPR_ASSERT(value);
-  GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == NULL);
+  GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == nullptr);
 
   if (count == capacity) {
     if (map->free > capacity / 4) {
@@ -73,9 +73,9 @@ void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
          won't help much */
       map->capacity = capacity = 3 * capacity / 2;
       map->keys = keys =
-          (uint32_t *)gpr_realloc(keys, capacity * sizeof(uint32_t));
+          (uint32_t*)gpr_realloc(keys, capacity * sizeof(uint32_t));
       map->values = values =
-          (void **)gpr_realloc(values, capacity * sizeof(void *));
+          (void**)gpr_realloc(values, capacity * sizeof(void*));
     }
   }
 
@@ -84,15 +84,15 @@ void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
   map->count = count + 1;
 }
 
-static void **find(grpc_chttp2_stream_map *map, uint32_t key) {
+static void** find(grpc_chttp2_stream_map* map, uint32_t key) {
   size_t min_idx = 0;
   size_t max_idx = map->count;
   size_t mid_idx;
-  uint32_t *keys = map->keys;
-  void **values = map->values;
+  uint32_t* keys = map->keys;
+  void** values = map->values;
   uint32_t mid_key;
 
-  if (max_idx == 0) return NULL;
+  if (max_idx == 0) return nullptr;
 
   while (min_idx < max_idx) {
     /* find the midpoint, avoiding overflow */
@@ -109,50 +109,51 @@ static void **find(grpc_chttp2_stream_map *map, uint32_t key) {
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
-void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map, uint32_t key) {
-  void **pvalue = find(map, key);
-  void *out = NULL;
-  if (pvalue != NULL) {
+void* grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map* map, uint32_t key) {
+  void** pvalue = find(map, key);
+  void* out = nullptr;
+  if (pvalue != nullptr) {
     out = *pvalue;
-    *pvalue = NULL;
-    map->free += (out != NULL);
+    *pvalue = nullptr;
+    map->free += (out != nullptr);
     /* recognize complete emptyness and ensure we can skip
      * defragmentation later */
     if (map->free == map->count) {
       map->free = map->count = 0;
     }
-    GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == NULL);
+    GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == nullptr);
   }
   return out;
 }
 
-void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, uint32_t key) {
-  void **pvalue = find(map, key);
-  return pvalue != NULL ? *pvalue : NULL;
+void* grpc_chttp2_stream_map_find(grpc_chttp2_stream_map* map, uint32_t key) {
+  void** pvalue = find(map, key);
+  return pvalue != nullptr ? *pvalue : nullptr;
 }
 
-size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map *map) {
+size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map* map) {
   return map->count - map->free;
 }
 
-void *grpc_chttp2_stream_map_rand(grpc_chttp2_stream_map *map) {
+void* grpc_chttp2_stream_map_rand(grpc_chttp2_stream_map* map) {
   if (map->count == map->free) {
-    return NULL;
+    return nullptr;
   }
   if (map->free != 0) {
     map->count = compact(map->keys, map->values, map->count);
     map->free = 0;
+    GPR_ASSERT(map->count > 0);
   }
   return map->values[((size_t)rand()) % map->count];
 }
 
-void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map,
-                                     void (*f)(void *user_data, uint32_t key,
-                                               void *value),
-                                     void *user_data) {
+void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map* map,
+                                     void (*f)(void* user_data, uint32_t key,
+                                               void* value),
+                                     void* user_data) {
   size_t i;
 
   for (i = 0; i < map->count; i++) {

data/src/core/ext/transport/chttp2/transport/stream_map.h

@@ -23,6 +23,10 @@
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Data structure to map a uint32_t to a data object (represented by a void*)
 
    Represented as a sorted array of keys, and a corresponding array of values.
@@ -30,39 +34,43 @@
    Adds are restricted to strictly higher keys than previously seen (this is
    guaranteed by http2). */
 typedef struct {
-  uint32_t *keys;
-  void **values;
+  uint32_t* keys;
+  void** values;
   size_t count;
   size_t free;
   size_t capacity;
 } grpc_chttp2_stream_map;
 
-void grpc_chttp2_stream_map_init(grpc_chttp2_stream_map *map,
+void grpc_chttp2_stream_map_init(grpc_chttp2_stream_map* map,
                                  size_t initial_capacity);
-void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map *map);
+void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map* map);
 
 /* Add a new key: given http2 semantics, new keys must always be greater than
    existing keys - this is asserted */
-void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
-                                void *value);
+void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map* map, uint32_t key,
+                                void* value);
 
 /* Delete an existing key - returns the previous value of the key if it existed,
    or NULL otherwise */
-void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map, uint32_t key);
+void* grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map* map, uint32_t key);
 
 /* Return an existing key, or NULL if it does not exist */
-void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, uint32_t key);
+void* grpc_chttp2_stream_map_find(grpc_chttp2_stream_map* map, uint32_t key);
 
 /* Return a random entry */
-void *grpc_chttp2_stream_map_rand(grpc_chttp2_stream_map *map);
+void* grpc_chttp2_stream_map_rand(grpc_chttp2_stream_map* map);
 
 /* How many (populated) entries are in the stream map? */
-size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map *map);
+size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map* map);
 
 /* Callback on each stream */
-void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map,
-                                     void (*f)(void *user_data, uint32_t key,
-                                               void *value),
-                                     void *user_data);
+void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map* map,
+                                     void (*f)(void* user_data, uint32_t key,
+                                               void* value),
+                                     void* user_data);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H */

data/src/core/ext/transport/chttp2/transport/varint.h

@@ -21,6 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Helpers for hpack varint encoding */
 
 /* length of a value that needs varint tail encoding (it's bigger than can be
@@ -57,4 +61,8 @@ void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
     }                                                                         \
   } while (0)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H */