grpc 0.13.0 → 0.13.1.pre1

data/include/grpc/impl/codegen/slice_buffer.h

@@ -59,13 +59,13 @@ typedef struct {
 } gpr_slice_buffer;
 
 /* initialize a slice buffer */
-GPR_API void gpr_slice_buffer_init(gpr_slice_buffer *sb);
+GPRAPI void gpr_slice_buffer_init(gpr_slice_buffer *sb);
 /* destroy a slice buffer - unrefs any held elements */
-GPR_API void gpr_slice_buffer_destroy(gpr_slice_buffer *sb);
+GPRAPI void gpr_slice_buffer_destroy(gpr_slice_buffer *sb);
 /* Add an element to a slice buffer - takes ownership of the slice.
    This function is allowed to concatenate the passed in slice to the end of
    some other slice if desired by the slice buffer. */
-GPR_API void gpr_slice_buffer_add(gpr_slice_buffer *sb, gpr_slice slice);
+GPRAPI void gpr_slice_buffer_add(gpr_slice_buffer *sb, gpr_slice slice);
 /* add an element to a slice buffer - takes ownership of the slice and returns
    the index of the slice.
    Guarantees that the slice will not be concatenated at the end of another
@@ -73,30 +73,30 @@ GPR_API void gpr_slice_buffer_add(gpr_slice_buffer *sb, gpr_slice slice);
    slice at the returned index in sb->slices)
    The implementation MAY decide to concatenate data at the end of a small
    slice added in this fashion. */
-GPR_API size_t
+GPRAPI size_t
 gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice slice);
-GPR_API void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices,
-                                   size_t n);
+GPRAPI void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices,
+                                  size_t n);
 /* add a very small (less than 8 bytes) amount of data to the end of a slice
    buffer: returns a pointer into which to add the data */
-GPR_API uint8_t *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t len);
+GPRAPI uint8_t *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t len);
 /* pop the last buffer, but don't unref it */
-GPR_API void gpr_slice_buffer_pop(gpr_slice_buffer *sb);
+GPRAPI void gpr_slice_buffer_pop(gpr_slice_buffer *sb);
 /* clear a slice buffer, unref all elements */
-GPR_API void gpr_slice_buffer_reset_and_unref(gpr_slice_buffer *sb);
+GPRAPI void gpr_slice_buffer_reset_and_unref(gpr_slice_buffer *sb);
 /* swap the contents of two slice buffers */
-GPR_API void gpr_slice_buffer_swap(gpr_slice_buffer *a, gpr_slice_buffer *b);
+GPRAPI void gpr_slice_buffer_swap(gpr_slice_buffer *a, gpr_slice_buffer *b);
 /* move all of the elements of src into dst */
-GPR_API void gpr_slice_buffer_move_into(gpr_slice_buffer *src,
-                                        gpr_slice_buffer *dst);
+GPRAPI void gpr_slice_buffer_move_into(gpr_slice_buffer *src,
+                                       gpr_slice_buffer *dst);
 /* remove n bytes from the end of a slice buffer */
-GPR_API void gpr_slice_buffer_trim_end(gpr_slice_buffer *src, size_t n,
-                                       gpr_slice_buffer *garbage);
+GPRAPI void gpr_slice_buffer_trim_end(gpr_slice_buffer *src, size_t n,
+                                      gpr_slice_buffer *garbage);
 /* move the first n bytes of src into dst */
-GPR_API void gpr_slice_buffer_move_first(gpr_slice_buffer *src, size_t n,
-                                         gpr_slice_buffer *dst);
+GPRAPI void gpr_slice_buffer_move_first(gpr_slice_buffer *src, size_t n,
+                                        gpr_slice_buffer *dst);
 /* take the first slice in the slice buffer */
-GPR_API gpr_slice gpr_slice_buffer_take_first(gpr_slice_buffer *src);
+GPRAPI gpr_slice gpr_slice_buffer_take_first(gpr_slice_buffer *src);
 
 #ifdef __cplusplus
 }

data/include/grpc/impl/codegen/sync.h

@@ -78,26 +78,26 @@ extern "C" {
    gpr_mu are uninitialized when first declared.  */
 
 /* Initialize *mu.  Requires:  *mu uninitialized.  */
-GPR_API void gpr_mu_init(gpr_mu *mu);
+GPRAPI void gpr_mu_init(gpr_mu *mu);
 
 /* Cause *mu no longer to be initialized, freeing any memory in use.  Requires:
    *mu initialized; no other concurrent operation on *mu.  */
-GPR_API void gpr_mu_destroy(gpr_mu *mu);
+GPRAPI void gpr_mu_destroy(gpr_mu *mu);
 
 /* Wait until no thread has a lock on *mu, cause the calling thread to own an
    exclusive lock on *mu, then return.  May block indefinitely or crash if the
    calling thread has a lock on *mu.  Requires:  *mu initialized.  */
-GPR_API void gpr_mu_lock(gpr_mu *mu);
+GPRAPI void gpr_mu_lock(gpr_mu *mu);
 
 /* Release an exclusive lock on *mu held by the calling thread.  Requires:  *mu
    initialized; the calling thread holds an exclusive lock on *mu.  */
-GPR_API void gpr_mu_unlock(gpr_mu *mu);
+GPRAPI void gpr_mu_unlock(gpr_mu *mu);
 
 /* Without blocking, attempt to acquire an exclusive lock on *mu for the
    calling thread, then return non-zero iff success.  Fail, if any thread holds
    the lock; succeeds with high probability if no thread holds the lock.
    Requires:  *mu initialized.  */
-GPR_API int gpr_mu_trylock(gpr_mu *mu);
+GPRAPI int gpr_mu_trylock(gpr_mu *mu);
 
 /* --- Condition variable interface ---
 
@@ -106,11 +106,11 @@ GPR_API int gpr_mu_trylock(gpr_mu *mu);
    uninitialized when first declared.  */
 
 /* Initialize *cv.  Requires:  *cv uninitialized.  */
-GPR_API void gpr_cv_init(gpr_cv *cv);
+GPRAPI void gpr_cv_init(gpr_cv *cv);
 
 /* Cause *cv no longer to be initialized, freeing any memory in use.  Requires:
    *cv initialized; no other concurrent operation on *cv.*/
-GPR_API void gpr_cv_destroy(gpr_cv *cv);
+GPRAPI void gpr_cv_destroy(gpr_cv *cv);
 
 /* Atomically release *mu and wait on *cv.  When the calling thread is woken
    from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu)
@@ -119,16 +119,16 @@ GPR_API void gpr_cv_destroy(gpr_cv *cv);
    an absolute deadline, or a GPR_TIMESPAN.  May return even when not
    woken explicitly.  Requires:  *mu and *cv initialized; the calling thread
    holds an exclusive lock on *mu.  */
-GPR_API int gpr_cv_wait(gpr_cv *cv, gpr_mu *mu, gpr_timespec abs_deadline);
+GPRAPI int gpr_cv_wait(gpr_cv *cv, gpr_mu *mu, gpr_timespec abs_deadline);
 
 /* If any threads are waiting on *cv, wake at least one.
    Clients may treat this as an optimization of gpr_cv_broadcast()
    for use in the case where waking more than one waiter is not useful.
    Requires:  *cv initialized.  */
-GPR_API void gpr_cv_signal(gpr_cv *cv);
+GPRAPI void gpr_cv_signal(gpr_cv *cv);
 
 /* Wake all threads waiting on *cv.  Requires:  *cv initialized.  */
-GPR_API void gpr_cv_broadcast(gpr_cv *cv);
+GPRAPI void gpr_cv_broadcast(gpr_cv *cv);
 
 /* --- One-time initialization ---
 
@@ -141,7 +141,7 @@ GPR_API void gpr_cv_broadcast(gpr_cv *cv);
    If multiple threads call gpr_once() on the same gpr_once instance, one of
    them will call (*init_routine)(), and the others will block until that call
    finishes.*/
-GPR_API void gpr_once_init(gpr_once *once, void (*init_routine)(void));
+GPRAPI void gpr_once_init(gpr_once *once, void (*init_routine)(void));
 
 /* --- One-time event notification ---
 
@@ -151,43 +151,47 @@ GPR_API void gpr_once_init(gpr_once *once, void (*init_routine)(void));
   It requires no destruction.  */
 
 /* Initialize *ev. */
-GPR_API void gpr_event_init(gpr_event *ev);
+GPRAPI void gpr_event_init(gpr_event *ev);
 
 /* Set *ev so that gpr_event_get() and gpr_event_wait() will return value.
    Requires:  *ev initialized; value != NULL; no prior or concurrent calls to
    gpr_event_set(ev, ...) since initialization.  */
-GPR_API void gpr_event_set(gpr_event *ev, void *value);
+GPRAPI void gpr_event_set(gpr_event *ev, void *value);
 
 /* Return the value set by gpr_event_set(ev, ...), or NULL if no such call has
    completed.  If the result is non-NULL, all operations that occurred prior to
    the gpr_event_set(ev, ...) set will be visible after this call returns.
    Requires:  *ev initialized.  This operation is faster than acquiring a mutex
    on most platforms.  */
-GPR_API void *gpr_event_get(gpr_event *ev);
+GPRAPI void *gpr_event_get(gpr_event *ev);
 
 /* Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is
    exceeded, then return gpr_event_get(ev).  Requires:  *ev initialized.  Use
    abs_deadline==gpr_inf_future for no deadline.  When the event has been
    signalled before the call, this operation is faster than acquiring a mutex
    on most platforms.  */
-GPR_API void *gpr_event_wait(gpr_event *ev, gpr_timespec abs_deadline);
+GPRAPI void *gpr_event_wait(gpr_event *ev, gpr_timespec abs_deadline);
 
 /* --- Reference counting ---
 
    These calls act on the type gpr_refcount.  It requires no destruction.  */
 
 /* Initialize *r to value n.  */
-GPR_API void gpr_ref_init(gpr_refcount *r, int n);
+GPRAPI void gpr_ref_init(gpr_refcount *r, int n);
 
 /* Increment the reference count *r.  Requires *r initialized. */
-GPR_API void gpr_ref(gpr_refcount *r);
+GPRAPI void gpr_ref(gpr_refcount *r);
+
+/* Increment the reference count *r.  Requires *r initialized.
+   Crashes if refcount is zero */
+GPRAPI void gpr_ref_non_zero(gpr_refcount *r);
 
 /* Increment the reference count *r by n.  Requires *r initialized, n > 0. */
-GPR_API void gpr_refn(gpr_refcount *r, int n);
+GPRAPI void gpr_refn(gpr_refcount *r, int n);
 
 /* Decrement the reference count *r and return non-zero iff it has reached
    zero. .  Requires *r initialized. */
-GPR_API int gpr_unref(gpr_refcount *r);
+GPRAPI int gpr_unref(gpr_refcount *r);
 
 /* --- Stats counters ---
 
@@ -198,13 +202,13 @@ GPR_API int gpr_unref(gpr_refcount *r);
    synchronize other events.  */
 
 /* Initialize *c to the value n. */
-GPR_API void gpr_stats_init(gpr_stats_counter *c, intptr_t n);
+GPRAPI void gpr_stats_init(gpr_stats_counter *c, intptr_t n);
 
 /* *c += inc.  Requires: *c initialized. */
-GPR_API void gpr_stats_inc(gpr_stats_counter *c, intptr_t inc);
+GPRAPI void gpr_stats_inc(gpr_stats_counter *c, intptr_t inc);
 
 /* Return *c.  Requires: *c initialized. */
-GPR_API intptr_t gpr_stats_read(const gpr_stats_counter *c);
+GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter *c);
 
 /* ==================Example use of interface===================
    A producer-consumer queue of up to N integers,

data/include/grpc/impl/codegen/time.h

@@ -69,10 +69,10 @@ typedef struct gpr_timespec {
 } gpr_timespec;
 
 /* Time constants. */
-GPR_API gpr_timespec
+GPRAPI gpr_timespec
 gpr_time_0(gpr_clock_type type); /* The zero time interval. */
-GPR_API gpr_timespec gpr_inf_future(gpr_clock_type type); /* The far future */
-GPR_API gpr_timespec gpr_inf_past(gpr_clock_type type);   /* The far past. */
+GPRAPI gpr_timespec gpr_inf_future(gpr_clock_type type); /* The far future */
+GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type);   /* The far past. */
 
 #define GPR_MS_PER_SEC 1000
 #define GPR_US_PER_SEC 1000000
@@ -82,48 +82,46 @@ GPR_API gpr_timespec gpr_inf_past(gpr_clock_type type);   /* The far past. */
 #define GPR_US_PER_MS 1000
 
 /* initialize time subsystem */
-GPR_API void gpr_time_init(void);
+GPRAPI void gpr_time_init(void);
 
 /* Return the current time measured from the given clocks epoch. */
-GPR_API gpr_timespec gpr_now(gpr_clock_type clock);
+GPRAPI gpr_timespec gpr_now(gpr_clock_type clock);
 
 /* Convert a timespec from one clock to another */
-GPR_API gpr_timespec
+GPRAPI gpr_timespec
 gpr_convert_clock_type(gpr_timespec t, gpr_clock_type target_clock);
 
 /* Return -ve, 0, or +ve according to whether a < b, a == b, or a > b
    respectively.  */
-GPR_API int gpr_time_cmp(gpr_timespec a, gpr_timespec b);
+GPRAPI int gpr_time_cmp(gpr_timespec a, gpr_timespec b);
 
-GPR_API gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b);
-GPR_API gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b);
 
 /* Add and subtract times.  Calculations saturate at infinities. */
-GPR_API gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b);
-GPR_API gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b);
 
 /* Return a timespec representing a given number of time units. INT64_MIN is
    interpreted as gpr_inf_past, and INT64_MAX as gpr_inf_future.  */
-GPR_API gpr_timespec gpr_time_from_micros(int64_t x, gpr_clock_type clock_type);
-GPR_API gpr_timespec gpr_time_from_nanos(int64_t x, gpr_clock_type clock_type);
-GPR_API gpr_timespec gpr_time_from_millis(int64_t x, gpr_clock_type clock_type);
-GPR_API gpr_timespec
-gpr_time_from_seconds(int64_t x, gpr_clock_type clock_type);
-GPR_API gpr_timespec
-gpr_time_from_minutes(int64_t x, gpr_clock_type clock_type);
-GPR_API gpr_timespec gpr_time_from_hours(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_micros(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_nanos(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_millis(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_seconds(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_minutes(int64_t x, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_hours(int64_t x, gpr_clock_type clock_type);
 
-GPR_API int32_t gpr_time_to_millis(gpr_timespec timespec);
+GPRAPI int32_t gpr_time_to_millis(gpr_timespec timespec);
 
 /* Return 1 if two times are equal or within threshold of each other,
    0 otherwise */
-GPR_API int gpr_time_similar(gpr_timespec a, gpr_timespec b,
-                             gpr_timespec threshold);
+GPRAPI int gpr_time_similar(gpr_timespec a, gpr_timespec b,
+                            gpr_timespec threshold);
 
 /* Sleep until at least 'until' - an absolute timeout */
-GPR_API void gpr_sleep_until(gpr_timespec until);
+GPRAPI void gpr_sleep_until(gpr_timespec until);
 
-GPR_API double gpr_timespec_to_micros(gpr_timespec t);
+GPRAPI double gpr_timespec_to_micros(gpr_timespec t);
 
 #ifdef __cplusplus
 }

data/include/grpc/support/avl.h

@@ -69,23 +69,24 @@ typedef struct gpr_avl {
 } gpr_avl;
 
 /** create an immutable AVL tree */
-GPR_API gpr_avl gpr_avl_create(const gpr_avl_vtable *vtable);
+GPRAPI gpr_avl gpr_avl_create(const gpr_avl_vtable *vtable);
 /** add a reference to an existing tree - returns
     the tree as a convenience */
-GPR_API gpr_avl gpr_avl_ref(gpr_avl avl);
+GPRAPI gpr_avl gpr_avl_ref(gpr_avl avl);
 /** remove a reference to a tree - destroying it if there
     are no references left */
-GPR_API void gpr_avl_unref(gpr_avl avl);
+GPRAPI void gpr_avl_unref(gpr_avl avl);
 /** 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) */
-GPR_API gpr_avl gpr_avl_add(gpr_avl avl, void *key, void *value);
-/** return a new tree with key deleted */
-GPR_API gpr_avl gpr_avl_remove(gpr_avl avl, void *key);
+GPRAPI gpr_avl gpr_avl_add(gpr_avl avl, void *key, void *value);
+/** return a new tree with key deleted
+    implicitly unrefs avl to allow easy chaining. */
+GPRAPI gpr_avl gpr_avl_remove(gpr_avl avl, void *key);
 /** lookup key, and return the associated value.
     does not mutate avl.
     returns NULL if key is not found. */
-GPR_API void *gpr_avl_get(gpr_avl avl, void *key);
+GPRAPI void *gpr_avl_get(gpr_avl avl, void *key);
 
-#endif
+#endif /* GRPC_SUPPORT_AVL_H */

data/include/grpc/support/cmdline.h

@@ -70,31 +70,31 @@ typedef struct gpr_cmdline gpr_cmdline;
 
 /* Construct a command line parser: takes a short description of the tool
    doing the parsing */
-GPR_API gpr_cmdline *gpr_cmdline_create(const char *description);
+GPRAPI gpr_cmdline *gpr_cmdline_create(const char *description);
 /* Add an integer parameter, with a name (used on the command line) and some
    helpful text (used in the command usage) */
-GPR_API void gpr_cmdline_add_int(gpr_cmdline *cl, const char *name,
-                                 const char *help, int *value);
+GPRAPI void gpr_cmdline_add_int(gpr_cmdline *cl, const char *name,
+                                const char *help, int *value);
 /* The same, for a boolean flag */
-GPR_API void gpr_cmdline_add_flag(gpr_cmdline *cl, const char *name,
-                                  const char *help, int *value);
+GPRAPI void gpr_cmdline_add_flag(gpr_cmdline *cl, const char *name,
+                                 const char *help, int *value);
 /* And for a string */
-GPR_API void gpr_cmdline_add_string(gpr_cmdline *cl, const char *name,
-                                    const char *help, char **value);
+GPRAPI void gpr_cmdline_add_string(gpr_cmdline *cl, const char *name,
+                                   const char *help, char **value);
 /* Set a callback for non-named arguments */
-GPR_API void gpr_cmdline_on_extra_arg(
+GPRAPI void gpr_cmdline_on_extra_arg(
     gpr_cmdline *cl, const char *name, const char *help,
     void (*on_extra_arg)(void *user_data, const char *arg), void *user_data);
 /* Enable surviving failure: default behavior is to exit the process */
-GPR_API void gpr_cmdline_set_survive_failure(gpr_cmdline *cl);
+GPRAPI void gpr_cmdline_set_survive_failure(gpr_cmdline *cl);
 /* Parse the command line; returns 1 on success, on failure either dies
    (by default) or returns 0 if gpr_cmdline_set_survive_failure() has been
    called */
-GPR_API int gpr_cmdline_parse(gpr_cmdline *cl, int argc, char **argv);
+GPRAPI int gpr_cmdline_parse(gpr_cmdline *cl, int argc, char **argv);
 /* Destroy the parser */
-GPR_API void gpr_cmdline_destroy(gpr_cmdline *cl);
+GPRAPI void gpr_cmdline_destroy(gpr_cmdline *cl);
 /* Get a string describing usage */
-GPR_API char *gpr_cmdline_usage_string(gpr_cmdline *cl, const char *argv0);
+GPRAPI char *gpr_cmdline_usage_string(gpr_cmdline *cl, const char *argv0);
 
 #ifdef __cplusplus
 }

data/include/grpc/support/cpu.h

@@ -44,13 +44,13 @@ extern "C" {
 
 /* Return the number of CPU cores on the current system. Will return 0 if
    the information is not available. */
-GPR_API unsigned gpr_cpu_num_cores(void);
+GPRAPI unsigned gpr_cpu_num_cores(void);
 
 /* Return the CPU on which the current thread is executing; N.B. This should
    be considered advisory only - it is possible that the thread is switched
    to a different CPU at any time. Returns a value in range
    [0, gpr_cpu_num_cores() - 1] */
-GPR_API unsigned gpr_cpu_current_cpu(void);
+GPRAPI unsigned gpr_cpu_current_cpu(void);
 
 #ifdef __cplusplus
 }  // extern "C"

data/include/grpc/support/histogram.h

@@ -43,34 +43,34 @@ extern "C" {
 
 typedef struct gpr_histogram gpr_histogram;
 
-GPR_API gpr_histogram *gpr_histogram_create(double resolution,
-                                            double max_bucket_start);
-GPR_API void gpr_histogram_destroy(gpr_histogram *h);
-GPR_API void gpr_histogram_add(gpr_histogram *h, double x);
+GPRAPI gpr_histogram *gpr_histogram_create(double resolution,
+                                           double max_bucket_start);
+GPRAPI void gpr_histogram_destroy(gpr_histogram *h);
+GPRAPI void gpr_histogram_add(gpr_histogram *h, double x);
 
 /* The following merges the second histogram into the first. It only works
    if they have the same buckets and resolution. Returns 0 on failure, 1
    on success */
-GPR_API int gpr_histogram_merge(gpr_histogram *dst, const gpr_histogram *src);
+GPRAPI int gpr_histogram_merge(gpr_histogram *dst, const gpr_histogram *src);
 
-GPR_API double gpr_histogram_percentile(gpr_histogram *histogram,
-                                        double percentile);
-GPR_API double gpr_histogram_mean(gpr_histogram *histogram);
-GPR_API double gpr_histogram_stddev(gpr_histogram *histogram);
-GPR_API double gpr_histogram_variance(gpr_histogram *histogram);
-GPR_API double gpr_histogram_maximum(gpr_histogram *histogram);
-GPR_API double gpr_histogram_minimum(gpr_histogram *histogram);
-GPR_API double gpr_histogram_count(gpr_histogram *histogram);
-GPR_API double gpr_histogram_sum(gpr_histogram *histogram);
-GPR_API double gpr_histogram_sum_of_squares(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_percentile(gpr_histogram *histogram,
+                                       double percentile);
+GPRAPI double gpr_histogram_mean(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_stddev(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_variance(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_maximum(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_minimum(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_count(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_sum(gpr_histogram *histogram);
+GPRAPI double gpr_histogram_sum_of_squares(gpr_histogram *histogram);
 
-GPR_API const uint32_t *gpr_histogram_get_contents(gpr_histogram *histogram,
-                                                   size_t *count);
-GPR_API void gpr_histogram_merge_contents(gpr_histogram *histogram,
-                                          const uint32_t *data,
-                                          size_t data_count, double min_seen,
-                                          double max_seen, double sum,
-                                          double sum_of_squares, double count);
+GPRAPI const uint32_t *gpr_histogram_get_contents(gpr_histogram *histogram,
+                                                  size_t *count);
+GPRAPI void gpr_histogram_merge_contents(gpr_histogram *histogram,
+                                         const uint32_t *data,
+                                         size_t data_count, double min_seen,
+                                         double max_seen, double sum,
+                                         double sum_of_squares, double count);
 
 #ifdef __cplusplus
 }

data/include/grpc/support/host_port.h

@@ -50,14 +50,14 @@ extern "C" {
    destroyed using gpr_free().
 
    In the unlikely event of an error, returns -1 and sets *out to NULL. */
-GPR_API int gpr_join_host_port(char **out, const char *host, int port);
+GPRAPI int gpr_join_host_port(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, into newly allocated strings, which must later be
    destroyed using gpr_free().
    Return 1 on success, 0 on failure. Guarantees *host and *port == NULL on
    failure. */
-GPR_API int gpr_split_host_port(const char *name, char **host, char **port);
+GPRAPI int gpr_split_host_port(const char *name, char **host, char **port);
 
 #ifdef __cplusplus
 }