grpc 1.7.3 → 1.8.0

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

@@ -24,6 +24,10 @@
 #include "src/core/lib/channel/handshaker_factory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum {
   HANDSHAKER_CLIENT = 0,
   HANDSHAKER_SERVER,
@@ -45,4 +49,8 @@ void grpc_handshakers_add(grpc_exec_ctx* exec_ctx,
                           const grpc_channel_args* args,
                           grpc_handshake_manager* handshake_mgr);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_REGISTRY_H */

data/src/core/lib/compression/algorithm_metadata.h

@@ -22,6 +22,10 @@
 #include <grpc/compression.h>
 #include "src/core/lib/transport/metadata.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Return compression algorithm based metadata value */
 grpc_slice grpc_compression_algorithm_slice(
     grpc_compression_algorithm algorithm);
@@ -49,4 +53,8 @@ grpc_compression_algorithm grpc_compression_algorithm_from_slice(
 grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
     grpc_slice str);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

data/src/core/lib/compression/{compression.c → compression.cc}

@@ -27,7 +27,7 @@
 #include "src/core/lib/transport/static_metadata.h"
 
 int grpc_compression_algorithm_parse(grpc_slice name,
-                                     grpc_compression_algorithm *algorithm) {
+                                     grpc_compression_algorithm* algorithm) {
   /* we use strncmp not only because it's safer (even though in this case it
    * doesn't matter, given that we are comparing against string literals, but
    * because this way we needn't have "name" nil-terminated (useful for slice
@@ -47,7 +47,7 @@ int grpc_compression_algorithm_parse(grpc_slice name,
 }
 
 int grpc_stream_compression_algorithm_parse(
-    grpc_slice name, grpc_stream_compression_algorithm *algorithm) {
+    grpc_slice name, grpc_stream_compression_algorithm* algorithm) {
   if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_STREAM_COMPRESS_NONE;
     return 1;
@@ -60,7 +60,7 @@ int grpc_stream_compression_algorithm_parse(
 }
 
 int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
-                                    const char **name) {
+                                    const char** name) {
   GRPC_API_TRACE("grpc_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
                  ((int)algorithm, name));
   switch (algorithm) {
@@ -80,7 +80,7 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
 }
 
 int grpc_stream_compression_algorithm_name(
-    grpc_stream_compression_algorithm algorithm, const char **name) {
+    grpc_stream_compression_algorithm algorithm, const char** name) {
   GRPC_API_TRACE(
       "grpc_stream_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
       ((int)algorithm, name));
@@ -168,7 +168,7 @@ grpc_mdelem grpc_stream_compression_encoding_mdelem(
   return GRPC_MDNULL;
 }
 
-void grpc_compression_options_init(grpc_compression_options *opts) {
+void grpc_compression_options_init(grpc_compression_options* opts) {
   memset(opts, 0, sizeof(*opts));
   /* all enabled by default */
   opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
@@ -177,23 +177,23 @@ void grpc_compression_options_init(grpc_compression_options *opts) {
 }
 
 void grpc_compression_options_enable_algorithm(
-    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+    grpc_compression_options* opts, grpc_compression_algorithm algorithm) {
   GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
 }
 
 void grpc_compression_options_disable_algorithm(
-    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+    grpc_compression_options* opts, grpc_compression_algorithm algorithm) {
   GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
 }
 
 int grpc_compression_options_is_algorithm_enabled(
-    const grpc_compression_options *opts,
+    const grpc_compression_options* opts,
     grpc_compression_algorithm algorithm) {
   return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
 }
 
 int grpc_compression_options_is_stream_compression_algorithm_enabled(
-    const grpc_compression_options *opts,
+    const grpc_compression_options* opts,
     grpc_stream_compression_algorithm algorithm) {
   return GPR_BITGET(opts->enabled_stream_compression_algorithms_bitset,
                     algorithm);

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

@@ -22,6 +22,10 @@
 #include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.
    On failure, appends uncompressed slices to output and returns 0. */
@@ -36,4 +40,8 @@ int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
                         grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */

data/src/core/lib/compression/{stream_compression.c → stream_compression.cc}

@@ -21,26 +21,26 @@
 #include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/compression/stream_compression_gzip.h"
 
-extern const grpc_stream_compression_vtable
+extern "C" const grpc_stream_compression_vtable
     grpc_stream_compression_identity_vtable;
 
-bool grpc_stream_compress(grpc_stream_compression_context *ctx,
-                          grpc_slice_buffer *in, grpc_slice_buffer *out,
-                          size_t *output_size, size_t max_output_size,
+bool grpc_stream_compress(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) {
   return ctx->vtable->compress(ctx, in, out, output_size, max_output_size,
                                flush);
 }
 
-bool grpc_stream_decompress(grpc_stream_compression_context *ctx,
-                            grpc_slice_buffer *in, grpc_slice_buffer *out,
-                            size_t *output_size, size_t max_output_size,
-                            bool *end_of_context) {
+bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
+                            grpc_slice_buffer* in, grpc_slice_buffer* out,
+                            size_t* output_size, size_t max_output_size,
+                            bool* end_of_context) {
   return ctx->vtable->decompress(ctx, in, out, output_size, max_output_size,
                                  end_of_context);
 }
 
-grpc_stream_compression_context *grpc_stream_compression_context_create(
+grpc_stream_compression_context* grpc_stream_compression_context_create(
     grpc_stream_compression_method method) {
   switch (method) {
     case GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS:
@@ -51,18 +51,18 @@ grpc_stream_compression_context *grpc_stream_compression_context_create(
       return grpc_stream_compression_gzip_vtable.context_create(method);
     default:
       gpr_log(GPR_ERROR, "Unknown stream compression method: %d", method);
-      return NULL;
+      return nullptr;
   }
 }
 
 void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context *ctx) {
+    grpc_stream_compression_context* ctx) {
   ctx->vtable->context_destroy(ctx);
 }
 
 int grpc_stream_compression_method_parse(
     grpc_slice value, bool is_compress,
-    grpc_stream_compression_method *method) {
+    grpc_stream_compression_method* method) {
   if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
     *method = is_compress ? GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
                           : GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;

data/src/core/lib/compression/stream_compression.h

@@ -26,11 +26,15 @@
 
 #include "src/core/lib/transport/static_metadata.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_stream_compression_vtable grpc_stream_compression_vtable;
 
 /* Stream compression/decompression context */
 typedef struct grpc_stream_compression_context {
-  const grpc_stream_compression_vtable *vtable;
+  const grpc_stream_compression_vtable* vtable;
 } grpc_stream_compression_context;
 
 typedef enum grpc_stream_compression_method {
@@ -49,16 +53,16 @@ typedef enum grpc_stream_compression_flush {
 } grpc_stream_compression_flush;
 
 struct grpc_stream_compression_vtable {
-  bool (*compress)(grpc_stream_compression_context *ctx, grpc_slice_buffer *in,
-                   grpc_slice_buffer *out, size_t *output_size,
+  bool (*compress)(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);
-  bool (*decompress)(grpc_stream_compression_context *ctx,
-                     grpc_slice_buffer *in, grpc_slice_buffer *out,
-                     size_t *output_size, size_t max_output_size,
-                     bool *end_of_context);
-  grpc_stream_compression_context *(*context_create)(
+  bool (*decompress)(grpc_stream_compression_context* ctx,
+                     grpc_slice_buffer* in, grpc_slice_buffer* out,
+                     size_t* output_size, size_t max_output_size,
+                     bool* end_of_context);
+  grpc_stream_compression_context* (*context_create)(
       grpc_stream_compression_method method);
-  void (*context_destroy)(grpc_stream_compression_context *ctx);
+  void (*context_destroy)(grpc_stream_compression_context* ctx);
 };
 
 /**
@@ -74,9 +78,9 @@ struct grpc_stream_compression_vtable {
  * previous compressed bytes. It allows corresponding decompression context to
  * be dropped when reaching this boundary.
  */
-bool grpc_stream_compress(grpc_stream_compression_context *ctx,
-                          grpc_slice_buffer *in, grpc_slice_buffer *out,
-                          size_t *output_size, size_t max_output_size,
+bool grpc_stream_compress(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);
 
 /**
@@ -86,29 +90,33 @@ bool grpc_stream_compress(grpc_stream_compression_context *ctx,
  * it is set to false. The total number of bytes emitted is outputed in \a
  * output_size.
  */
-bool grpc_stream_decompress(grpc_stream_compression_context *ctx,
-                            grpc_slice_buffer *in, grpc_slice_buffer *out,
-                            size_t *output_size, size_t max_output_size,
-                            bool *end_of_context);
+bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
+                            grpc_slice_buffer* in, grpc_slice_buffer* out,
+                            size_t* output_size, size_t max_output_size,
+                            bool* end_of_context);
 
 /**
  * Creates a stream compression context. \a pending_bytes_buffer is the input
  * buffer for compression/decompression operations. \a method specifies whether
  * the context is for compression or decompression.
  */
-grpc_stream_compression_context *grpc_stream_compression_context_create(
+grpc_stream_compression_context* grpc_stream_compression_context_create(
     grpc_stream_compression_method method);
 
 /**
  * Destroys a stream compression context.
  */
 void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context *ctx);
+    grpc_stream_compression_context* ctx);
 
 /**
  * Parse stream compression method based on algorithm name
  */
 int grpc_stream_compression_method_parse(
-    grpc_slice value, bool is_compress, grpc_stream_compression_method *method);
+    grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif

data/src/core/lib/compression/{stream_compression_gzip.c → stream_compression_gzip.cc}

@@ -29,13 +29,13 @@ typedef struct grpc_stream_compression_context_gzip {
   grpc_stream_compression_context base;
 
   z_stream zs;
-  int (*flate)(z_stream *zs, int flush);
+  int (*flate)(z_stream* zs, int flush);
 } grpc_stream_compression_context_gzip;
 
-static bool gzip_flate(grpc_stream_compression_context_gzip *ctx,
-                       grpc_slice_buffer *in, grpc_slice_buffer *out,
-                       size_t *output_size, size_t max_output_size, int flush,
-                       bool *end_of_context) {
+static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
+                       grpc_slice_buffer* in, grpc_slice_buffer* out,
+                       size_t* output_size, size_t max_output_size, int flush,
+                       bool* end_of_context) {
   GPR_ASSERT(flush == 0 || flush == Z_SYNC_FLUSH || flush == Z_FINISH);
   /* Full flush is not allowed when inflating. */
   GPR_ASSERT(!(ctx->flate == inflate && (flush == Z_FINISH)));
@@ -131,17 +131,17 @@ static bool gzip_flate(grpc_stream_compression_context_gzip *ctx,
   return true;
 }
 
-static bool grpc_stream_compress_gzip(grpc_stream_compression_context *ctx,
-                                      grpc_slice_buffer *in,
-                                      grpc_slice_buffer *out,
-                                      size_t *output_size,
+static bool grpc_stream_compress_gzip(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 == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
-  grpc_stream_compression_context_gzip *gzip_ctx =
-      (grpc_stream_compression_context_gzip *)ctx;
+  grpc_stream_compression_context_gzip* gzip_ctx =
+      (grpc_stream_compression_context_gzip*)ctx;
   GPR_ASSERT(gzip_ctx->flate == deflate);
   int gzip_flush;
   switch (flush) {
@@ -158,36 +158,36 @@ static bool grpc_stream_compress_gzip(grpc_stream_compression_context *ctx,
       gzip_flush = 0;
   }
   return gzip_flate(gzip_ctx, in, out, output_size, max_output_size, gzip_flush,
-                    NULL);
+                    nullptr);
 }
 
-static bool grpc_stream_decompress_gzip(grpc_stream_compression_context *ctx,
-                                        grpc_slice_buffer *in,
-                                        grpc_slice_buffer *out,
-                                        size_t *output_size,
+static bool grpc_stream_decompress_gzip(grpc_stream_compression_context* ctx,
+                                        grpc_slice_buffer* in,
+                                        grpc_slice_buffer* out,
+                                        size_t* output_size,
                                         size_t max_output_size,
-                                        bool *end_of_context) {
-  if (ctx == NULL) {
+                                        bool* end_of_context) {
+  if (ctx == nullptr) {
     return false;
   }
-  grpc_stream_compression_context_gzip *gzip_ctx =
-      (grpc_stream_compression_context_gzip *)ctx;
+  grpc_stream_compression_context_gzip* gzip_ctx =
+      (grpc_stream_compression_context_gzip*)ctx;
   GPR_ASSERT(gzip_ctx->flate == inflate);
   return gzip_flate(gzip_ctx, in, out, output_size, max_output_size,
                     Z_SYNC_FLUSH, end_of_context);
 }
 
-static grpc_stream_compression_context *
+static grpc_stream_compression_context*
 grpc_stream_compression_context_create_gzip(
     grpc_stream_compression_method method) {
   GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_GZIP_COMPRESS ||
              method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
-  grpc_stream_compression_context_gzip *gzip_ctx =
-      (grpc_stream_compression_context_gzip *)gpr_zalloc(
+  grpc_stream_compression_context_gzip* gzip_ctx =
+      (grpc_stream_compression_context_gzip*)gpr_zalloc(
           sizeof(grpc_stream_compression_context_gzip));
   int r;
-  if (gzip_ctx == NULL) {
-    return NULL;
+  if (gzip_ctx == nullptr) {
+    return nullptr;
   }
   if (method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS) {
     r = inflateInit2(&gzip_ctx->zs, 0x1F);
@@ -199,20 +199,20 @@ grpc_stream_compression_context_create_gzip(
   }
   if (r != Z_OK) {
     gpr_free(gzip_ctx);
-    return NULL;
+    return nullptr;
   }
 
   gzip_ctx->base.vtable = &grpc_stream_compression_gzip_vtable;
-  return (grpc_stream_compression_context *)gzip_ctx;
+  return (grpc_stream_compression_context*)gzip_ctx;
 }
 
 static void grpc_stream_compression_context_destroy_gzip(
-    grpc_stream_compression_context *ctx) {
-  if (ctx == NULL) {
+    grpc_stream_compression_context* ctx) {
+  if (ctx == nullptr) {
     return;
   }
-  grpc_stream_compression_context_gzip *gzip_ctx =
-      (grpc_stream_compression_context_gzip *)ctx;
+  grpc_stream_compression_context_gzip* gzip_ctx =
+      (grpc_stream_compression_context_gzip*)ctx;
   if (gzip_ctx->flate == inflate) {
     inflateEnd(&gzip_ctx->zs);
   } else {
@@ -222,7 +222,6 @@ static void grpc_stream_compression_context_destroy_gzip(
 }
 
 const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable = {
-    .compress = grpc_stream_compress_gzip,
-    .decompress = grpc_stream_decompress_gzip,
-    .context_create = grpc_stream_compression_context_create_gzip,
-    .context_destroy = grpc_stream_compression_context_destroy_gzip};
+    grpc_stream_compress_gzip, grpc_stream_decompress_gzip,
+    grpc_stream_compression_context_create_gzip,
+    grpc_stream_compression_context_destroy_gzip};

data/src/core/lib/compression/stream_compression_gzip.h

@@ -21,6 +21,14 @@
 
 #include "src/core/lib/compression/stream_compression.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/src/core/lib/compression/{stream_compression_identity.c → stream_compression_identity.cc}

@@ -27,11 +27,11 @@
 
 /* Singleton context used for all identity streams. */
 static grpc_stream_compression_context identity_ctx = {
-    .vtable = &grpc_stream_compression_identity_vtable};
+    &grpc_stream_compression_identity_vtable};
 
-static void grpc_stream_compression_pass_through(grpc_slice_buffer *in,
-                                                 grpc_slice_buffer *out,
-                                                 size_t *output_size,
+static void grpc_stream_compression_pass_through(grpc_slice_buffer* in,
+                                                 grpc_slice_buffer* out,
+                                                 size_t* output_size,
                                                  size_t max_output_size) {
   if (max_output_size >= in->length) {
     if (output_size) {
@@ -46,13 +46,13 @@ 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,
+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 == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_pass_through(in, out, output_size, max_output_size);
@@ -60,10 +60,10 @@ static bool grpc_stream_compress_identity(grpc_stream_compression_context *ctx,
 }
 
 static bool grpc_stream_decompress_identity(
-    grpc_stream_compression_context *ctx, grpc_slice_buffer *in,
-    grpc_slice_buffer *out, size_t *output_size, size_t max_output_size,
-    bool *end_of_context) {
-  if (ctx == NULL) {
+    grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
+    grpc_slice_buffer* out, size_t* output_size, size_t max_output_size,
+    bool* end_of_context) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_pass_through(in, out, output_size, max_output_size);
@@ -73,22 +73,21 @@ static bool grpc_stream_decompress_identity(
   return true;
 }
 
-static grpc_stream_compression_context *
+static grpc_stream_compression_context*
 grpc_stream_compression_context_create_identity(
     grpc_stream_compression_method method) {
   GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS ||
              method == GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS);
   /* No context needed in this case. Use fake context instead. */
-  return (grpc_stream_compression_context *)&identity_ctx;
+  return (grpc_stream_compression_context*)&identity_ctx;
 }
 
 static void grpc_stream_compression_context_destroy_identity(
-    grpc_stream_compression_context *ctx) {
+    grpc_stream_compression_context* ctx) {
   return;
 }
 
 const grpc_stream_compression_vtable grpc_stream_compression_identity_vtable = {
-    .compress = grpc_stream_compress_identity,
-    .decompress = grpc_stream_decompress_identity,
-    .context_create = grpc_stream_compression_context_create_identity,
-    .context_destroy = grpc_stream_compression_context_destroy_identity};
+    grpc_stream_compress_identity, grpc_stream_decompress_identity,
+    grpc_stream_compression_context_create_identity,
+    grpc_stream_compression_context_destroy_identity};