grpc 0.13.0 → 0.13.1.pre1

data/include/grpc/grpc_security.h

@@ -65,39 +65,39 @@ typedef struct grpc_auth_property {
 } grpc_auth_property;
 
 /* Returns NULL when the iterator is at the end. */
-GRPC_API const grpc_auth_property *grpc_auth_property_iterator_next(
+GRPCAPI const grpc_auth_property *grpc_auth_property_iterator_next(
     grpc_auth_property_iterator *it);
 
 /* Iterates over the auth context. */
-GRPC_API grpc_auth_property_iterator
+GRPCAPI grpc_auth_property_iterator
 grpc_auth_context_property_iterator(const grpc_auth_context *ctx);
 
 /* Gets the peer identity. Returns an empty iterator (first _next will return
    NULL) if the peer is not authenticated. */
-GRPC_API grpc_auth_property_iterator
+GRPCAPI grpc_auth_property_iterator
 grpc_auth_context_peer_identity(const grpc_auth_context *ctx);
 
 /* Finds a property in the context. May return an empty iterator (first _next
    will return NULL) if no property with this name was found in the context. */
-GRPC_API grpc_auth_property_iterator
+GRPCAPI grpc_auth_property_iterator
 grpc_auth_context_find_properties_by_name(const grpc_auth_context *ctx,
                                           const char *name);
 
 /* Gets the name of the property that indicates the peer identity. Will return
    NULL if the peer is not authenticated. */
-GRPC_API const char *grpc_auth_context_peer_identity_property_name(
+GRPCAPI const char *grpc_auth_context_peer_identity_property_name(
     const grpc_auth_context *ctx);
 
 /* Returns 1 if the peer is authenticated, 0 otherwise. */
-GRPC_API int grpc_auth_context_peer_is_authenticated(
+GRPCAPI int grpc_auth_context_peer_is_authenticated(
     const grpc_auth_context *ctx);
 
 /* Gets the auth context from the call. Caller needs to call
    grpc_auth_context_release on the returned context. */
-GRPC_API grpc_auth_context *grpc_call_auth_context(grpc_call *call);
+GRPCAPI grpc_auth_context *grpc_call_auth_context(grpc_call *call);
 
 /* Releases the auth context returned from grpc_call_auth_context. */
-GRPC_API void grpc_auth_context_release(grpc_auth_context *context);
+GRPCAPI void grpc_auth_context_release(grpc_auth_context *context);
 
 /* --
    The following auth context methods should only be called by a server metadata
@@ -105,19 +105,18 @@ GRPC_API void grpc_auth_context_release(grpc_auth_context *context);
    -- */
 
 /* Add a property. */
-GRPC_API void grpc_auth_context_add_property(grpc_auth_context *ctx,
-                                             const char *name,
-                                             const char *value,
-                                             size_t value_length);
+GRPCAPI void grpc_auth_context_add_property(grpc_auth_context *ctx,
+                                            const char *name, const char *value,
+                                            size_t value_length);
 
 /* Add a C string property. */
-GRPC_API void grpc_auth_context_add_cstring_property(grpc_auth_context *ctx,
-                                                     const char *name,
-                                                     const char *value);
+GRPCAPI void grpc_auth_context_add_cstring_property(grpc_auth_context *ctx,
+                                                    const char *name,
+                                                    const char *value);
 
 /* Sets the property name. Returns 1 if successful or 0 in case of failure
    (which means that no property with this name exists). */
-GRPC_API int grpc_auth_context_set_peer_identity_property_name(
+GRPCAPI int grpc_auth_context_set_peer_identity_property_name(
     grpc_auth_context *ctx, const char *name);
 
 /* --- grpc_channel_credentials object. ---
@@ -129,7 +128,7 @@ typedef struct grpc_channel_credentials grpc_channel_credentials;
 
 /* Releases a channel credentials object.
    The creator of the credentials object is responsible for its release. */
-GRPC_API void grpc_channel_credentials_release(grpc_channel_credentials *creds);
+GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials *creds);
 
 /* Environment variable that points to the google default application
    credentials json key or refresh token. Used in the
@@ -139,7 +138,7 @@ GRPC_API void grpc_channel_credentials_release(grpc_channel_credentials *creds);
 /* Creates default credentials to connect to a google gRPC service.
    WARNING: Do NOT use this credentials to connect to a non-google service as
    this could result in an oauth2 token leak. */
-GRPC_API grpc_channel_credentials *grpc_google_default_credentials_create(void);
+GRPCAPI grpc_channel_credentials *grpc_google_default_credentials_create(void);
 
 /* Environment variable that points to the default SSL roots file. This file
    must be a PEM encoded file with all the roots such as the one that can be
@@ -168,7 +167,8 @@ typedef grpc_ssl_roots_override_result (*grpc_ssl_roots_override_callback)(
    before any ssl credentials are created to have the desired side effect.
    If GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is set to a valid path, the
    callback will not be called. */
-void grpc_set_ssl_roots_override_callback(grpc_ssl_roots_override_callback cb);
+GRPCAPI void grpc_set_ssl_roots_override_callback(
+    grpc_ssl_roots_override_callback cb);
 
 /* Object that holds a private key / certificate chain pair in PEM format. */
 typedef struct {
@@ -192,7 +192,7 @@ typedef struct {
    - pem_key_cert_pair is a pointer on the object containing client's private
      key and certificate chain. This parameter can be NULL if the client does
      not have such a key/cert pair. */
-GRPC_API grpc_channel_credentials *grpc_ssl_credentials_create(
+GRPCAPI grpc_channel_credentials *grpc_ssl_credentials_create(
     const char *pem_root_certs, grpc_ssl_pem_key_cert_pair *pem_key_cert_pair,
     void *reserved);
 
@@ -206,32 +206,32 @@ typedef struct grpc_call_credentials grpc_call_credentials;
 
 /* Releases a call credentials object.
    The creator of the credentials object is responsible for its release. */
-GRPC_API void grpc_call_credentials_release(grpc_call_credentials *creds);
+GRPCAPI void grpc_call_credentials_release(grpc_call_credentials *creds);
 
 /* Creates a composite channel credentials object. */
-GRPC_API grpc_channel_credentials *grpc_composite_channel_credentials_create(
+GRPCAPI grpc_channel_credentials *grpc_composite_channel_credentials_create(
     grpc_channel_credentials *channel_creds, grpc_call_credentials *call_creds,
     void *reserved);
 
 /* Creates a composite call credentials object. */
-GRPC_API grpc_call_credentials *grpc_composite_call_credentials_create(
+GRPCAPI grpc_call_credentials *grpc_composite_call_credentials_create(
     grpc_call_credentials *creds1, grpc_call_credentials *creds2,
     void *reserved);
 
 /* Creates a compute engine credentials object for connecting to Google.
    WARNING: Do NOT use this credentials to connect to a non-google service as
    this could result in an oauth2 token leak. */
-GRPC_API grpc_call_credentials *grpc_google_compute_engine_credentials_create(
+GRPCAPI grpc_call_credentials *grpc_google_compute_engine_credentials_create(
     void *reserved);
 
-GRPC_API gpr_timespec grpc_max_auth_token_lifetime();
+GRPCAPI gpr_timespec grpc_max_auth_token_lifetime();
 
 /* Creates a JWT credentials object. May return NULL if the input is invalid.
    - json_key is the JSON key string containing the client's private key.
    - token_lifetime is the lifetime of each Json Web Token (JWT) created with
      this credentials.  It should not exceed grpc_max_auth_token_lifetime or
      will be cropped to this value.  */
-GRPC_API grpc_call_credentials *
+GRPCAPI grpc_call_credentials *
 grpc_service_account_jwt_access_credentials_create(const char *json_key,
                                                    gpr_timespec token_lifetime,
                                                    void *reserved);
@@ -242,16 +242,16 @@ grpc_service_account_jwt_access_credentials_create(const char *json_key,
    this could result in an oauth2 token leak.
    - json_refresh_token is the JSON string containing the refresh token itself
      along with a client_id and client_secret. */
-GRPC_API grpc_call_credentials *grpc_google_refresh_token_credentials_create(
+GRPCAPI grpc_call_credentials *grpc_google_refresh_token_credentials_create(
     const char *json_refresh_token, void *reserved);
 
 /* Creates an Oauth2 Access Token credentials with an access token that was
    aquired by an out of band mechanism. */
-GRPC_API grpc_call_credentials *grpc_access_token_credentials_create(
+GRPCAPI grpc_call_credentials *grpc_access_token_credentials_create(
     const char *access_token, void *reserved);
 
 /* Creates an IAM credentials object for connecting to Google. */
-GRPC_API grpc_call_credentials *grpc_google_iam_credentials_create(
+GRPCAPI grpc_call_credentials *grpc_google_iam_credentials_create(
     const char *authorization_token, const char *authority_selector,
     void *reserved);
 
@@ -313,13 +313,13 @@ typedef struct {
 } grpc_metadata_credentials_plugin;
 
 /* Creates a credentials object from a plugin. */
-GRPC_API grpc_call_credentials *grpc_metadata_credentials_create_from_plugin(
+GRPCAPI grpc_call_credentials *grpc_metadata_credentials_create_from_plugin(
     grpc_metadata_credentials_plugin plugin, void *reserved);
 
 /* --- Secure channel creation. --- */
 
 /* Creates a secure channel using the passed-in credentials. */
-GRPC_API grpc_channel *grpc_secure_channel_create(
+GRPCAPI grpc_channel *grpc_secure_channel_create(
     grpc_channel_credentials *creds, const char *target,
     const grpc_channel_args *args, void *reserved);
 
@@ -332,7 +332,7 @@ typedef struct grpc_server_credentials grpc_server_credentials;
 /* Releases a server_credentials object.
    The creator of the server_credentials object is responsible for its release.
    */
-GRPC_API void grpc_server_credentials_release(grpc_server_credentials *creds);
+GRPCAPI void grpc_server_credentials_release(grpc_server_credentials *creds);
 
 /* Creates an SSL server_credentials object.
    - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
@@ -345,7 +345,7 @@ GRPC_API void grpc_server_credentials_release(grpc_server_credentials *creds);
    - force_client_auth, if set to non-zero will force the client to authenticate
      with an SSL cert. Note that this option is ignored if pem_root_certs is
      NULL. */
-GRPC_API grpc_server_credentials *grpc_ssl_server_credentials_create(
+GRPCAPI grpc_server_credentials *grpc_ssl_server_credentials_create(
     const char *pem_root_certs, grpc_ssl_pem_key_cert_pair *pem_key_cert_pairs,
     size_t num_key_cert_pairs, int force_client_auth, void *reserved);
 
@@ -354,15 +354,15 @@ GRPC_API grpc_server_credentials *grpc_ssl_server_credentials_create(
 /* Add a HTTP2 over an encrypted link over tcp listener.
    Returns bound port number on success, 0 on failure.
    REQUIRES: server not started */
-GRPC_API int grpc_server_add_secure_http2_port(grpc_server *server,
-                                               const char *addr,
-                                               grpc_server_credentials *creds);
+GRPCAPI int grpc_server_add_secure_http2_port(grpc_server *server,
+                                              const char *addr,
+                                              grpc_server_credentials *creds);
 
 /* --- Call specific credentials. --- */
 
 /* Sets a credentials to a call. Can only be called on the client side before
    grpc_call_start_batch. */
-GRPC_API grpc_call_error
+GRPCAPI grpc_call_error
 grpc_call_set_credentials(grpc_call *call, grpc_call_credentials *creds);
 
 /* --- Auth Metadata Processing --- */
@@ -394,7 +394,7 @@ typedef struct {
   void *state;
 } grpc_auth_metadata_processor;
 
-GRPC_API void grpc_server_credentials_set_auth_metadata_processor(
+GRPCAPI void grpc_server_credentials_set_auth_metadata_processor(
     grpc_server_credentials *creds, grpc_auth_metadata_processor processor);
 
 #ifdef __cplusplus

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

@@ -49,23 +49,23 @@ typedef struct gpr_allocation_functions {
 } gpr_allocation_functions;
 
 /* malloc, never returns NULL */
-GPR_API void *gpr_malloc(size_t size);
+GPRAPI void *gpr_malloc(size_t size);
 /* free */
-GPR_API void gpr_free(void *ptr);
+GPRAPI void gpr_free(void *ptr);
 /* realloc, never returns NULL */
-GPR_API void *gpr_realloc(void *p, size_t size);
+GPRAPI void *gpr_realloc(void *p, size_t size);
 /* aligned malloc, never returns NULL, will align to 1 << alignment_log */
-GPR_API void *gpr_malloc_aligned(size_t size, size_t alignment_log);
+GPRAPI void *gpr_malloc_aligned(size_t size, size_t alignment_log);
 /* free memory allocated by gpr_malloc_aligned */
-GPR_API void gpr_free_aligned(void *ptr);
+GPRAPI void gpr_free_aligned(void *ptr);
 
 /** Request the family of allocation functions in \a functions be used. NOTE
  * that this request will be honored in a *best effort* basis and that no
  * guarantees are made about the default functions (eg, malloc) being called. */
-GPR_API void gpr_set_allocation_functions(gpr_allocation_functions functions);
+GPRAPI void gpr_set_allocation_functions(gpr_allocation_functions functions);
 
 /** Return the family of allocation functions currently in effect. */
-GPR_API gpr_allocation_functions gpr_get_allocation_functions();
+GPRAPI gpr_allocation_functions gpr_get_allocation_functions();
 
 #ifdef __cplusplus
 }

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

@@ -65,8 +65,8 @@ typedef struct grpc_byte_buffer grpc_byte_buffer;
  *
  * Increases the reference count for all \a slices processed. The user is
  * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
-GRPC_API grpc_byte_buffer *grpc_raw_byte_buffer_create(gpr_slice *slices,
-                                                       size_t nslices);
+GRPCAPI grpc_byte_buffer *grpc_raw_byte_buffer_create(gpr_slice *slices,
+                                                      size_t nslices);
 
 /** Returns a *compressed* RAW byte buffer instance over the given slices (up to
  * \a nslices). The \a compression argument defines the compression algorithm
@@ -74,44 +74,44 @@ GRPC_API grpc_byte_buffer *grpc_raw_byte_buffer_create(gpr_slice *slices,
  *
  * Increases the reference count for all \a slices processed. The user is
  * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
-GRPC_API grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create(
+GRPCAPI grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create(
     gpr_slice *slices, size_t nslices, grpc_compression_algorithm compression);
 
 /** Copies input byte buffer \a bb.
  *
  * Increases the reference count of all the source slices. The user is
  * responsible for calling grpc_byte_buffer_destroy over the returned copy. */
-GRPC_API grpc_byte_buffer *grpc_byte_buffer_copy(grpc_byte_buffer *bb);
+GRPCAPI grpc_byte_buffer *grpc_byte_buffer_copy(grpc_byte_buffer *bb);
 
 /** Returns the size of the given byte buffer, in bytes. */
-GRPC_API size_t grpc_byte_buffer_length(grpc_byte_buffer *bb);
+GRPCAPI size_t grpc_byte_buffer_length(grpc_byte_buffer *bb);
 
 /** Destroys \a byte_buffer deallocating all its memory. */
-GRPC_API void grpc_byte_buffer_destroy(grpc_byte_buffer *byte_buffer);
+GRPCAPI void grpc_byte_buffer_destroy(grpc_byte_buffer *byte_buffer);
 
 /** Reader for byte buffers. Iterates over slices in the byte buffer */
 struct grpc_byte_buffer_reader;
 typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader;
 
 /** Initialize \a reader to read over \a buffer */
-GRPC_API void grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
-                                           grpc_byte_buffer *buffer);
+GRPCAPI void grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
+                                          grpc_byte_buffer *buffer);
 
 /** Cleanup and destroy \a reader */
-GRPC_API void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader);
+GRPCAPI void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader);
 
 /** Updates \a slice with the next piece of data from from \a reader and returns
  * 1. Returns 0 at the end of the stream. Caller is responsible for calling
  * gpr_slice_unref on the result. */
-GRPC_API int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader,
-                                          gpr_slice *slice);
+GRPCAPI int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader,
+                                         gpr_slice *slice);
 
 /** Merge all data from \a reader into single slice */
-GRPC_API gpr_slice
+GRPCAPI gpr_slice
 grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader *reader);
 
 /** Returns a RAW byte buffer instance from the output of \a reader. */
-GRPC_API grpc_byte_buffer *grpc_raw_byte_buffer_from_reader(
+GRPCAPI grpc_byte_buffer *grpc_raw_byte_buffer_from_reader(
     grpc_byte_buffer_reader *reader);
 
 #ifdef __cplusplus

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

@@ -68,6 +68,12 @@ typedef enum {
   GRPC_ARG_POINTER
 } grpc_arg_type;
 
+typedef struct grpc_arg_pointer_vtable {
+  void *(*copy)(void *p);
+  void (*destroy)(void *p);
+  int (*cmp)(void *p, void *q);
+} grpc_arg_pointer_vtable;
+
 /** A single argument... each argument has a key and a value
 
     A note on naming keys:
@@ -88,8 +94,7 @@ typedef struct {
     int integer;
     struct {
       void *p;
-      void *(*copy)(void *p);
-      void (*destroy)(void *p);
+      const grpc_arg_pointer_vtable *vtable;
     } pointer;
   } value;
 } grpc_arg;

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

@@ -71,11 +71,11 @@ const char *gpr_log_severity_string(gpr_log_severity severity);
 
 /* Log a message. It's advised to use GPR_xxx above to generate the context
  * for each message */
-GPR_API void gpr_log(const char *file, int line, gpr_log_severity severity,
-                     const char *format, ...);
+GPRAPI void gpr_log(const char *file, int line, gpr_log_severity severity,
+                    const char *format, ...);
 
-GPR_API void gpr_log_message(const char *file, int line,
-                             gpr_log_severity severity, const char *message);
+GPRAPI void gpr_log_message(const char *file, int line,
+                            gpr_log_severity severity, const char *message);
 
 /* Log overrides: applications can use this API to intercept logging calls
    and use their own implementations */
@@ -88,7 +88,7 @@ typedef struct {
 } gpr_log_func_args;
 
 typedef void (*gpr_log_func)(gpr_log_func_args *args);
-GPR_API void gpr_set_log_function(gpr_log_func func);
+GPRAPI void gpr_set_log_function(gpr_log_func func);
 
 /* abort() the process if x is zero, having written a line to the log.
 

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

@@ -34,6 +34,14 @@
 #ifndef GRPC_IMPL_CODEGEN_PORT_PLATFORM_H
 #define GRPC_IMPL_CODEGEN_PORT_PLATFORM_H
 
+/*
+ * Define GPR_BACKWARDS_COMPATIBILITY_MODE to try harder to be ABI
+ * compatible with older platforms (currently only on Linux)
+ * Causes:
+ *  - some libc calls to be gotten via dlsym
+ *  - some syscalls to be made directly
+ */
+
 /* Get windows.h included everywhere (we need it) */
 #if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
 #ifndef WIN32_LEAN_AND_MEAN
@@ -347,16 +355,16 @@ typedef unsigned __int64 uint64_t;
   } while (0)
 #endif /* GPR_FORBID_UNREACHABLE_CODE */
 
-#ifndef GPR_API
-#define GPR_API
+#ifndef GPRAPI
+#define GPRAPI
 #endif
 
-#ifndef GRPC_API
-#define GRPC_API GPR_API
+#ifndef GRPCAPI
+#define GRPCAPI GPRAPI
 #endif
 
-#ifndef CENSUS_API
-#define CENSUS_API GRPC_API
+#ifndef CENSUSAPI
+#define CENSUSAPI GRPCAPI
 #endif
 
 #endif /* GRPC_IMPL_CODEGEN_PORT_PLATFORM_H */

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

@@ -105,7 +105,7 @@ typedef struct gpr_slice {
 
 /* Increment the refcount of s. Requires slice is initialized.
    Returns s. */
-GPR_API gpr_slice gpr_slice_ref(gpr_slice s);
+GPRAPI gpr_slice gpr_slice_ref(gpr_slice s);
 
 /* Decrement the ref count of s.  If the ref count of s reaches zero, all
    slices sharing the ref count are destroyed, and considered no longer
@@ -113,22 +113,22 @@ GPR_API gpr_slice gpr_slice_ref(gpr_slice s);
    len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is
    ultimately derived from a call to gpr_slice_new_with_len(start, len, dest)
    where dest!=NULL , then (*dest)(start, len).  Requires s initialized.  */
-GPR_API void gpr_slice_unref(gpr_slice s);
+GPRAPI void gpr_slice_unref(gpr_slice s);
 
 /* Create a slice pointing at some data. Calls malloc to allocate a refcount
    for the object, and arranges that destroy will be called with the pointer
    passed in at destruction. */
-GPR_API gpr_slice gpr_slice_new(void *p, size_t len, void (*destroy)(void *));
+GPRAPI gpr_slice gpr_slice_new(void *p, size_t len, void (*destroy)(void *));
 
 /* Equivalent to gpr_slice_new, but with a two argument destroy function that
    also takes the slice length. */
-GPR_API gpr_slice
+GPRAPI gpr_slice
 gpr_slice_new_with_len(void *p, size_t len, void (*destroy)(void *, size_t));
 
 /* Equivalent to gpr_slice_new(malloc(len), len, free), but saves one malloc()
    call.
    Aborts if malloc() fails. */
-GPR_API gpr_slice gpr_slice_malloc(size_t length);
+GPRAPI gpr_slice gpr_slice_malloc(size_t length);
 
 /* Create a slice by copying a string.
    Does not preserve null terminators.
@@ -136,44 +136,44 @@ GPR_API gpr_slice gpr_slice_malloc(size_t length);
      size_t len = strlen(source);
      gpr_slice slice = gpr_slice_malloc(len);
      memcpy(slice->data, source, len); */
-GPR_API gpr_slice gpr_slice_from_copied_string(const char *source);
+GPRAPI gpr_slice gpr_slice_from_copied_string(const char *source);
 
 /* Create a slice by copying a buffer.
    Equivalent to:
      gpr_slice slice = gpr_slice_malloc(len);
      memcpy(slice->data, source, len); */
-GPR_API gpr_slice gpr_slice_from_copied_buffer(const char *source, size_t len);
+GPRAPI gpr_slice gpr_slice_from_copied_buffer(const char *source, size_t len);
 
 /* Create a slice pointing to constant memory */
-GPR_API gpr_slice gpr_slice_from_static_string(const char *source);
+GPRAPI gpr_slice gpr_slice_from_static_string(const char *source);
 
 /* Return a result slice derived from s, which shares a ref count with s, where
    result.data==s.data+begin, and result.length==end-begin.
    The ref count of s is increased by one.
    Requires s initialized, begin <= end, begin <= s.length, and
    end <= source->length. */
-GPR_API gpr_slice gpr_slice_sub(gpr_slice s, size_t begin, size_t end);
+GPRAPI gpr_slice gpr_slice_sub(gpr_slice s, size_t begin, size_t end);
 
 /* The same as gpr_slice_sub, but without altering the ref count */
-GPR_API gpr_slice gpr_slice_sub_no_ref(gpr_slice s, size_t begin, size_t end);
+GPRAPI gpr_slice gpr_slice_sub_no_ref(gpr_slice s, size_t begin, size_t end);
 
 /* Splits s into two: modifies s to be s[0:split], and returns a new slice,
    sharing a refcount with s, that contains s[split:s.length].
    Requires s intialized, split <= s.length */
-GPR_API gpr_slice gpr_slice_split_tail(gpr_slice *s, size_t split);
+GPRAPI gpr_slice gpr_slice_split_tail(gpr_slice *s, size_t split);
 
 /* Splits s into two: modifies s to be s[split:s.length], and returns a new
    slice, sharing a refcount with s, that contains s[0:split].
    Requires s intialized, split <= s.length */
-GPR_API gpr_slice gpr_slice_split_head(gpr_slice *s, size_t split);
+GPRAPI gpr_slice gpr_slice_split_head(gpr_slice *s, size_t split);
 
-GPR_API gpr_slice gpr_empty_slice(void);
+GPRAPI gpr_slice gpr_empty_slice(void);
 
 /* Returns <0 if a < b, ==0 if a == b, >0 if a > b
    The order is arbitrary, and is not guaranteed to be stable across different
    versions of the API. */
-GPR_API int gpr_slice_cmp(gpr_slice a, gpr_slice b);
-GPR_API int gpr_slice_str_cmp(gpr_slice a, const char *b);
+GPRAPI int gpr_slice_cmp(gpr_slice a, gpr_slice b);
+GPRAPI int gpr_slice_str_cmp(gpr_slice a, const char *b);
 
 #ifdef __cplusplus
 }