clang-format

8 files changed, 83 insertions, 83 deletions

diff --git a/src/core/lib/compression/compression.cc b/src/core/lib/compression/compression.cc
index 20c1743d4a..88fb37ffe2 100644
--- a/src/core/lib/compression/compression.cc
+++ b/src/core/lib/compression/compression.cc
@@ -40,7 +40,7 @@ int grpc_compression_algorithm_is_stream(grpc_compression_algorithm algorithm) {
 }
 
 int grpc_compression_algorithm_parse(grpc_slice name,
-                                     grpc_compression_algorithm *algorithm) {
+                                     grpc_compression_algorithm* algorithm) {
   if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
@@ -60,7 +60,7 @@ int grpc_compression_algorithm_parse(grpc_slice name,
 }
 
 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) {
@@ -110,24 +110,24 @@ grpc_compression_algorithm grpc_compression_algorithm_for_level(
   }
 }
 
-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;
 }
 
 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);
 }
diff --git a/src/core/lib/compression/compression_internal.cc b/src/core/lib/compression/compression_internal.cc
index e31eb830f1..8352ad255e 100644
--- a/src/core/lib/compression/compression_internal.cc
+++ b/src/core/lib/compression/compression_internal.cc
@@ -144,7 +144,7 @@ uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
 }
 
 int grpc_compression_algorithm_from_message_stream_compression_algorithm(
-    grpc_compression_algorithm *algorithm,
+    grpc_compression_algorithm* algorithm,
     grpc_message_compression_algorithm message_algorithm,
     grpc_stream_compression_algorithm stream_algorithm) {
   if (message_algorithm != GRPC_MESSAGE_COMPRESS_NONE &&
@@ -186,7 +186,7 @@ int grpc_compression_algorithm_from_message_stream_compression_algorithm(
 /* Interfaces for message compression. */
 
 int grpc_message_compression_algorithm_name(
-    grpc_message_compression_algorithm algorithm, const char **name) {
+    grpc_message_compression_algorithm algorithm, const char** name) {
   GRPC_API_TRACE(
       "grpc_message_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
       ((int)algorithm, name));
@@ -263,7 +263,7 @@ grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
 }
 
 int grpc_message_compression_algorithm_parse(
-    grpc_slice value, grpc_message_compression_algorithm *algorithm) {
+    grpc_slice value, grpc_message_compression_algorithm* algorithm) {
   if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_MESSAGE_COMPRESS_NONE;
     return 1;
@@ -299,7 +299,7 @@ grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
 }
 
 int grpc_stream_compression_algorithm_parse(
-    grpc_slice value, grpc_stream_compression_algorithm *algorithm) {
+    grpc_slice value, grpc_stream_compression_algorithm* algorithm) {
   if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_STREAM_COMPRESS_NONE;
     return 1;
diff --git a/src/core/lib/compression/compression_internal.h b/src/core/lib/compression/compression_internal.h
index aab5324b67..4279d4f697 100644
--- a/src/core/lib/compression/compression_internal.h
+++ b/src/core/lib/compression/compression_internal.h
@@ -88,20 +88,20 @@ uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
     uint32_t message_bitset, uint32_t stream_bitset);
 
 int grpc_compression_algorithm_from_message_stream_compression_algorithm(
-    grpc_compression_algorithm *algorithm,
+    grpc_compression_algorithm* algorithm,
     grpc_message_compression_algorithm message_algorithm,
     grpc_stream_compression_algorithm stream_algorithm);
 
 /* Interfaces for message compression. */
 
 int grpc_message_compression_algorithm_name(
-    grpc_message_compression_algorithm algorithm, const char **name);
+    grpc_message_compression_algorithm algorithm, const char** name);
 
 grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
     grpc_message_compression_level level, uint32_t accepted_encodings);
 
 int grpc_message_compression_algorithm_parse(
-    grpc_slice value, grpc_message_compression_algorithm *algorithm);
+    grpc_slice value, grpc_message_compression_algorithm* algorithm);
 
 /* Interfaces for stream compression. */
 
@@ -109,7 +109,7 @@ grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
     grpc_stream_compression_level level, uint32_t accepted_encodings);
 
 int grpc_stream_compression_algorithm_parse(
-    grpc_slice value, grpc_stream_compression_algorithm *algorithm);
+    grpc_slice value, grpc_stream_compression_algorithm* algorithm);
 
 #ifdef __cplusplus
 }
diff --git a/src/core/lib/compression/compression_ruby.cc b/src/core/lib/compression/compression_ruby.cc
index 7e75507b85..293062f5ed 100644
--- a/src/core/lib/compression/compression_ruby.cc
+++ b/src/core/lib/compression/compression_ruby.cc
@@ -23,7 +23,7 @@
 #include "src/core/lib/transport/static_metadata.h"
 
 int grpc_compression_algorithm_parse_ruby(
-    grpc_slice name, grpc_compression_algorithm *algorithm) {
+    grpc_slice name, grpc_compression_algorithm* algorithm) {
   if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
@@ -43,7 +43,7 @@ int grpc_compression_algorithm_parse_ruby(
 }
 
 int grpc_compression_algorithm_name_ruby(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) {
diff --git a/src/core/lib/compression/stream_compression.cc b/src/core/lib/compression/stream_compression.cc
index 7faeb0d34f..8a57b33230 100644
--- a/src/core/lib/compression/stream_compression.cc
+++ b/src/core/lib/compression/stream_compression.cc
@@ -24,23 +24,23 @@
 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:
@@ -56,13 +56,13 @@ grpc_stream_compression_context *grpc_stream_compression_context_create(
 }
 
 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;
diff --git a/src/core/lib/compression/stream_compression.h b/src/core/lib/compression/stream_compression.h
index 6ee3ac1966..b56c142543 100644
--- a/src/core/lib/compression/stream_compression.h
+++ b/src/core/lib/compression/stream_compression.h
@@ -34,7 +34,7 @@ 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 {
@@ -53,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);
 };
 
 /**
@@ -78,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);
 
 /**
@@ -90,30 +90,30 @@ 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
 }
diff --git a/src/core/lib/compression/stream_compression_gzip.cc b/src/core/lib/compression/stream_compression_gzip.cc
index 087b018be5..53ec7ca223 100644
--- a/src/core/lib/compression/stream_compression_gzip.cc
+++ b/src/core/lib/compression/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) {
     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) {
@@ -161,29 +161,29 @@ static bool grpc_stream_compress_gzip(grpc_stream_compression_context *ctx,
                     NULL);
 }
 
-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) {
+                                        bool* end_of_context) {
   if (ctx == NULL) {
     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) {
@@ -203,16 +203,16 @@ grpc_stream_compression_context_create_gzip(
   }
 
   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) {
+    grpc_stream_compression_context* ctx) {
   if (ctx == NULL) {
     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 {
diff --git a/src/core/lib/compression/stream_compression_identity.cc b/src/core/lib/compression/stream_compression_identity.cc
index 9b2e6062e1..5e8bfc09a6 100644
--- a/src/core/lib/compression/stream_compression_identity.cc
+++ b/src/core/lib/compression/stream_compression_identity.cc
@@ -29,9 +29,9 @@
 static grpc_stream_compression_context identity_ctx = {
     &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,10 +46,10 @@ 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) {
@@ -60,9 +60,9 @@ 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) {
+    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) {
     return false;
   }
@@ -73,17 +73,17 @@ 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;
 }