grpc 1.7.3 → 1.8.0

data/src/core/lib/transport/{status_conversion.c → status_conversion.cc}

@@ -37,8 +37,9 @@ grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status) {
   }
 }
 
-grpc_status_code grpc_http2_error_to_grpc_status(grpc_http2_error_code error,
-                                                 gpr_timespec deadline) {
+grpc_status_code grpc_http2_error_to_grpc_status(grpc_exec_ctx* exec_ctx,
+                                                 grpc_http2_error_code error,
+                                                 grpc_millis deadline) {
   switch (error) {
     case GRPC_HTTP2_NO_ERROR:
       /* should never be received */
@@ -46,7 +47,7 @@ grpc_status_code grpc_http2_error_to_grpc_status(grpc_http2_error_code error,
     case GRPC_HTTP2_CANCEL:
       /* http2 cancel translates to STATUS_CANCELLED iff deadline hasn't been
        * exceeded */
-      return gpr_time_cmp(gpr_now(deadline.clock_type), deadline) >= 0
+      return grpc_exec_ctx_now(exec_ctx) > deadline
                  ? GRPC_STATUS_DEADLINE_EXCEEDED
                  : GRPC_STATUS_CANCELLED;
     case GRPC_HTTP2_ENHANCE_YOUR_CALM:

data/src/core/lib/transport/status_conversion.h

@@ -20,15 +20,25 @@
 #define GRPC_CORE_LIB_TRANSPORT_STATUS_CONVERSION_H
 
 #include <grpc/grpc.h>
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/transport/http2_errors.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Conversion of grpc status codes to http2 error codes (for RST_STREAM) */
 grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status);
-grpc_status_code grpc_http2_error_to_grpc_status(grpc_http2_error_code error,
-                                                 gpr_timespec deadline);
+grpc_status_code grpc_http2_error_to_grpc_status(grpc_exec_ctx* exec_ctx,
+                                                 grpc_http2_error_code error,
+                                                 grpc_millis deadline);
 
 /* Conversion of HTTP status codes (:status) to grpc status codes */
 grpc_status_code grpc_http2_status_to_grpc_status(int status);
 int grpc_status_to_http2_status(grpc_status_code status);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_STATUS_CONVERSION_H */

data/src/core/lib/transport/{timeout_encoding.c → timeout_encoding.cc}

@@ -41,15 +41,15 @@ static int64_t round_up_to_three_sig_figs(int64_t x) {
 }
 
 /* encode our minimum viable timeout value */
-static void enc_tiny(char *buffer) { memcpy(buffer, "1n", 3); }
+static void enc_tiny(char* buffer) { memcpy(buffer, "1n", 3); }
 
-static void enc_ext(char *buffer, int64_t value, char ext) {
+static void enc_ext(char* buffer, int64_t value, char ext) {
   int n = int64_ttoa(value, buffer);
   buffer[n] = ext;
   buffer[n + 1] = 0;
 }
 
-static void enc_seconds(char *buffer, int64_t sec) {
+static void enc_seconds(char* buffer, int64_t sec) {
   if (sec % 3600 == 0) {
     enc_ext(buffer, sec / 3600, 'H');
   } else if (sec % 60 == 0) {
@@ -59,72 +59,39 @@ static void enc_seconds(char *buffer, int64_t sec) {
   }
 }
 
-static void enc_nanos(char *buffer, int64_t x) {
+static void enc_millis(char* buffer, int64_t x) {
   x = round_up_to_three_sig_figs(x);
-  if (x < 100000) {
-    if (x % 1000 == 0) {
-      enc_ext(buffer, x / 1000, 'u');
-    } else {
-      enc_ext(buffer, x, 'n');
-    }
-  } else if (x < 100000000) {
-    if (x % 1000000 == 0) {
-      enc_ext(buffer, x / 1000000, 'm');
-    } else {
-      enc_ext(buffer, x / 1000, 'u');
-    }
-  } else if (x < 1000000000) {
-    enc_ext(buffer, x / 1000000, 'm');
+  if (x < GPR_MS_PER_SEC) {
+    enc_ext(buffer, x, 'm');
   } else {
-    /* note that this is only ever called with times of less than one second,
-       so if we reach here the time must have been rounded up to a whole second
-       (and no more) */
-    memcpy(buffer, "1S", 3);
-  }
-}
-
-static void enc_micros(char *buffer, int64_t x) {
-  x = round_up_to_three_sig_figs(x);
-  if (x < 100000) {
-    if (x % 1000 == 0) {
-      enc_ext(buffer, x / 1000, 'm');
+    if (x % GPR_MS_PER_SEC == 0) {
+      enc_seconds(buffer, x / GPR_MS_PER_SEC);
     } else {
-      enc_ext(buffer, x, 'u');
+      enc_ext(buffer, x, 'm');
     }
-  } else if (x < 100000000) {
-    if (x % 1000000 == 0) {
-      enc_ext(buffer, x / 1000000, 'S');
-    } else {
-      enc_ext(buffer, x / 1000, 'm');
-    }
-  } else {
-    enc_ext(buffer, x / 1000000, 'S');
   }
 }
 
-void grpc_http2_encode_timeout(gpr_timespec timeout, char *buffer) {
-  if (timeout.tv_sec < 0) {
+void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer) {
+  if (timeout <= 0) {
     enc_tiny(buffer);
-  } else if (timeout.tv_sec == 0) {
-    enc_nanos(buffer, timeout.tv_nsec);
-  } else if (timeout.tv_sec < 1000 && timeout.tv_nsec != 0) {
-    enc_micros(buffer,
-               (int64_t)(timeout.tv_sec * 1000000) +
-                   (timeout.tv_nsec / 1000 + (timeout.tv_nsec % 1000 != 0)));
+  } else if (timeout < 1000 * GPR_MS_PER_SEC) {
+    enc_millis(buffer, timeout);
   } else {
-    enc_seconds(buffer, timeout.tv_sec + (timeout.tv_nsec != 0));
+    enc_seconds(buffer,
+                timeout / GPR_MS_PER_SEC + (timeout % GPR_MS_PER_SEC != 0));
   }
 }
 
-static int is_all_whitespace(const char *p, const char *end) {
+static int is_all_whitespace(const char* p, const char* end) {
   while (p != end && *p == ' ') p++;
   return p == end;
 }
 
-int grpc_http2_decode_timeout(grpc_slice text, gpr_timespec *timeout) {
-  int32_t x = 0;
-  const uint8_t *p = GRPC_SLICE_START_PTR(text);
-  const uint8_t *end = GRPC_SLICE_END_PTR(text);
+int grpc_http2_decode_timeout(grpc_slice text, grpc_millis* timeout) {
+  grpc_millis x = 0;
+  const uint8_t* p = GRPC_SLICE_START_PTR(text);
+  const uint8_t* end = GRPC_SLICE_END_PTR(text);
   int have_digit = 0;
   /* skip whitespace */
   for (; p != end && *p == ' '; p++)
@@ -136,7 +103,7 @@ int grpc_http2_decode_timeout(grpc_slice text, gpr_timespec *timeout) {
     /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
     if (x >= (100 * 1000 * 1000)) {
       if (x != (100 * 1000 * 1000) || digit != 0) {
-        *timeout = gpr_inf_future(GPR_TIMESPAN);
+        *timeout = GRPC_MILLIS_INF_FUTURE;
         return 1;
       }
     }
@@ -150,26 +117,26 @@ int grpc_http2_decode_timeout(grpc_slice text, gpr_timespec *timeout) {
   /* decode unit specifier */
   switch (*p) {
     case 'n':
-      *timeout = gpr_time_from_nanos(x, GPR_TIMESPAN);
+      *timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
       break;
     case 'u':
-      *timeout = gpr_time_from_micros(x, GPR_TIMESPAN);
+      *timeout = x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0);
       break;
     case 'm':
-      *timeout = gpr_time_from_millis(x, GPR_TIMESPAN);
+      *timeout = x;
       break;
     case 'S':
-      *timeout = gpr_time_from_seconds(x, GPR_TIMESPAN);
+      *timeout = x * GPR_MS_PER_SEC;
       break;
     case 'M':
-      *timeout = gpr_time_from_minutes(x, GPR_TIMESPAN);
+      *timeout = x * 60 * GPR_MS_PER_SEC;
       break;
     case 'H':
-      *timeout = gpr_time_from_hours(x, GPR_TIMESPAN);
+      *timeout = x * 60 * 60 * GPR_MS_PER_SEC;
       break;
     default:
       return 0;
   }
   p++;
-  return is_all_whitespace((const char *)p, (const char *)end);
+  return is_all_whitespace((const char*)p, (const char*)end);
 }

data/src/core/lib/transport/timeout_encoding.h

@@ -22,13 +22,22 @@
 #include <grpc/slice.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/support/string.h"
 
 #define GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE (GPR_LTOA_MIN_BUFSIZE + 1)
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Encode/decode timeouts to the GRPC over HTTP/2 format;
    encoding may round up arbitrarily */
-void grpc_http2_encode_timeout(gpr_timespec timeout, char *buffer);
-int grpc_http2_decode_timeout(grpc_slice text, gpr_timespec *timeout);
+void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer);
+int grpc_http2_decode_timeout(grpc_slice text, grpc_millis* timeout);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */

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

@@ -31,37 +31,35 @@
 #include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/transport_impl.h"
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_stream_refcount =
-    GRPC_TRACER_INITIALIZER(false, "stream_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount(false,
+                                                         "stream_refcount");
 
 #ifndef NDEBUG
-void grpc_stream_ref(grpc_stream_refcount *refcount, const char *reason) {
-  if (GRPC_TRACER_ON(grpc_trace_stream_refcount)) {
+void grpc_stream_ref(grpc_stream_refcount* refcount, const char* reason) {
+  if (grpc_trace_stream_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount->refs.count);
     gpr_log(GPR_DEBUG, "%s %p:%p   REF %" PRIdPTR "->%" PRIdPTR " %s",
             refcount->object_type, refcount, refcount->destroy.cb_arg, val,
             val + 1, reason);
   }
 #else
-void grpc_stream_ref(grpc_stream_refcount *refcount) {
+void grpc_stream_ref(grpc_stream_refcount* refcount) {
 #endif
   gpr_ref_non_zero(&refcount->refs);
 }
 
 #ifndef NDEBUG
-void grpc_stream_unref(grpc_exec_ctx *exec_ctx, grpc_stream_refcount *refcount,
-                       const char *reason) {
-  if (GRPC_TRACER_ON(grpc_trace_stream_refcount)) {
+void grpc_stream_unref(grpc_exec_ctx* exec_ctx, grpc_stream_refcount* refcount,
+                       const char* reason) {
+  if (grpc_trace_stream_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount->refs.count);
     gpr_log(GPR_DEBUG, "%s %p:%p UNREF %" PRIdPTR "->%" PRIdPTR " %s",
             refcount->object_type, refcount, refcount->destroy.cb_arg, val,
             val - 1, reason);
   }
 #else
-void grpc_stream_unref(grpc_exec_ctx *exec_ctx,
-                       grpc_stream_refcount *refcount) {
+void grpc_stream_unref(grpc_exec_ctx* exec_ctx,
+                       grpc_stream_refcount* refcount) {
 #endif
   if (gpr_unref(&refcount->refs)) {
     if (exec_ctx->flags & GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP) {
@@ -79,11 +77,11 @@ void grpc_stream_unref(grpc_exec_ctx *exec_ctx,
   }
 }
 
-#define STREAM_REF_FROM_SLICE_REF(p)         \
-  ((grpc_stream_refcount *)(((uint8_t *)p) - \
-                            offsetof(grpc_stream_refcount, slice_refcount)))
+#define STREAM_REF_FROM_SLICE_REF(p)       \
+  ((grpc_stream_refcount*)(((uint8_t*)p) - \
+                           offsetof(grpc_stream_refcount, slice_refcount)))
 
-static void slice_stream_ref(void *p) {
+static void slice_stream_ref(void* p) {
 #ifndef NDEBUG
   grpc_stream_ref(STREAM_REF_FROM_SLICE_REF(p), "slice");
 #else
@@ -91,7 +89,7 @@ static void slice_stream_ref(void *p) {
 #endif
 }
 
-static void slice_stream_unref(grpc_exec_ctx *exec_ctx, void *p) {
+static void slice_stream_unref(grpc_exec_ctx* exec_ctx, void* p) {
 #ifndef NDEBUG
   grpc_stream_unref(exec_ctx, STREAM_REF_FROM_SLICE_REF(p), "slice");
 #else
@@ -99,30 +97,31 @@ static void slice_stream_unref(grpc_exec_ctx *exec_ctx, void *p) {
 #endif
 }
 
-grpc_slice grpc_slice_from_stream_owned_buffer(grpc_stream_refcount *refcount,
-                                               void *buffer, size_t length) {
+grpc_slice grpc_slice_from_stream_owned_buffer(grpc_stream_refcount* refcount,
+                                               void* buffer, size_t length) {
   slice_stream_ref(&refcount->slice_refcount);
   grpc_slice res;
-  res.refcount = &refcount->slice_refcount,
-  res.data.refcounted.bytes = (uint8_t *)buffer;
+  res.refcount = &refcount->slice_refcount;
+  res.data.refcounted.bytes = (uint8_t*)buffer;
   res.data.refcounted.length = length;
   return res;
 }
 
 static const grpc_slice_refcount_vtable stream_ref_slice_vtable = {
-    .ref = slice_stream_ref,
-    .unref = slice_stream_unref,
-    .eq = grpc_slice_default_eq_impl,
-    .hash = grpc_slice_default_hash_impl};
+    slice_stream_ref,            /* ref */
+    slice_stream_unref,          /* unref */
+    grpc_slice_default_eq_impl,  /* eq */
+    grpc_slice_default_hash_impl /* hash */
+};
 
 #ifndef NDEBUG
-void grpc_stream_ref_init(grpc_stream_refcount *refcount, int initial_refs,
-                          grpc_iomgr_cb_func cb, void *cb_arg,
-                          const char *object_type) {
+void grpc_stream_ref_init(grpc_stream_refcount* refcount, int initial_refs,
+                          grpc_iomgr_cb_func cb, void* cb_arg,
+                          const char* object_type) {
   refcount->object_type = object_type;
 #else
-void grpc_stream_ref_init(grpc_stream_refcount *refcount, int initial_refs,
-                          grpc_iomgr_cb_func cb, void *cb_arg) {
+void grpc_stream_ref_init(grpc_stream_refcount* refcount, int initial_refs,
+                          grpc_iomgr_cb_func cb, void* cb_arg) {
 #endif
   gpr_ref_init(&refcount->refs, initial_refs);
   GRPC_CLOSURE_INIT(&refcount->destroy, cb, cb_arg, grpc_schedule_on_exec_ctx);
@@ -130,62 +129,63 @@ void grpc_stream_ref_init(grpc_stream_refcount *refcount, int initial_refs,
   refcount->slice_refcount.sub_refcount = &refcount->slice_refcount;
 }
 
-static void move64(uint64_t *from, uint64_t *to) {
+static void move64(uint64_t* from, uint64_t* to) {
   *to += *from;
   *from = 0;
 }
 
-void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats *from,
-                                       grpc_transport_one_way_stats *to) {
+void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats* from,
+                                       grpc_transport_one_way_stats* to) {
   move64(&from->framing_bytes, &to->framing_bytes);
   move64(&from->data_bytes, &to->data_bytes);
   move64(&from->header_bytes, &to->header_bytes);
 }
 
-void grpc_transport_move_stats(grpc_transport_stream_stats *from,
-                               grpc_transport_stream_stats *to) {
+void grpc_transport_move_stats(grpc_transport_stream_stats* from,
+                               grpc_transport_stream_stats* to) {
   grpc_transport_move_one_way_stats(&from->incoming, &to->incoming);
   grpc_transport_move_one_way_stats(&from->outgoing, &to->outgoing);
 }
 
-size_t grpc_transport_stream_size(grpc_transport *transport) {
+size_t grpc_transport_stream_size(grpc_transport* transport) {
   return transport->vtable->sizeof_stream;
 }
 
-void grpc_transport_destroy(grpc_exec_ctx *exec_ctx,
-                            grpc_transport *transport) {
+void grpc_transport_destroy(grpc_exec_ctx* exec_ctx,
+                            grpc_transport* transport) {
   transport->vtable->destroy(exec_ctx, transport);
 }
 
-int grpc_transport_init_stream(grpc_exec_ctx *exec_ctx,
-                               grpc_transport *transport, grpc_stream *stream,
-                               grpc_stream_refcount *refcount,
-                               const void *server_data, gpr_arena *arena) {
+int grpc_transport_init_stream(grpc_exec_ctx* exec_ctx,
+                               grpc_transport* transport, grpc_stream* stream,
+                               grpc_stream_refcount* refcount,
+                               const void* server_data, gpr_arena* arena) {
   return transport->vtable->init_stream(exec_ctx, transport, stream, refcount,
                                         server_data, arena);
 }
 
-void grpc_transport_perform_stream_op(grpc_exec_ctx *exec_ctx,
-                                      grpc_transport *transport,
-                                      grpc_stream *stream,
-                                      grpc_transport_stream_op_batch *op) {
+void grpc_transport_perform_stream_op(grpc_exec_ctx* exec_ctx,
+                                      grpc_transport* transport,
+                                      grpc_stream* stream,
+                                      grpc_transport_stream_op_batch* op) {
   transport->vtable->perform_stream_op(exec_ctx, transport, stream, op);
 }
 
-void grpc_transport_perform_op(grpc_exec_ctx *exec_ctx,
-                               grpc_transport *transport,
-                               grpc_transport_op *op) {
+void grpc_transport_perform_op(grpc_exec_ctx* exec_ctx,
+                               grpc_transport* transport,
+                               grpc_transport_op* op) {
   transport->vtable->perform_op(exec_ctx, transport, op);
 }
 
-void grpc_transport_set_pops(grpc_exec_ctx *exec_ctx, grpc_transport *transport,
-                             grpc_stream *stream,
-                             grpc_polling_entity *pollent) {
-  grpc_pollset *pollset;
-  grpc_pollset_set *pollset_set;
-  if ((pollset = grpc_polling_entity_pollset(pollent)) != NULL) {
+void grpc_transport_set_pops(grpc_exec_ctx* exec_ctx, grpc_transport* transport,
+                             grpc_stream* stream,
+                             grpc_polling_entity* pollent) {
+  grpc_pollset* pollset;
+  grpc_pollset_set* pollset_set;
+  if ((pollset = grpc_polling_entity_pollset(pollent)) != nullptr) {
     transport->vtable->set_pollset(exec_ctx, transport, stream, pollset);
-  } else if ((pollset_set = grpc_polling_entity_pollset_set(pollent)) != NULL) {
+  } else if ((pollset_set = grpc_polling_entity_pollset_set(pollent)) !=
+             nullptr) {
     transport->vtable->set_pollset_set(exec_ctx, transport, stream,
                                        pollset_set);
   } else {
@@ -193,16 +193,16 @@ void grpc_transport_set_pops(grpc_exec_ctx *exec_ctx, grpc_transport *transport,
   }
 }
 
-void grpc_transport_destroy_stream(grpc_exec_ctx *exec_ctx,
-                                   grpc_transport *transport,
-                                   grpc_stream *stream,
-                                   grpc_closure *then_schedule_closure) {
+void grpc_transport_destroy_stream(grpc_exec_ctx* exec_ctx,
+                                   grpc_transport* transport,
+                                   grpc_stream* stream,
+                                   grpc_closure* then_schedule_closure) {
   transport->vtable->destroy_stream(exec_ctx, transport, stream,
                                     then_schedule_closure);
 }
 
-grpc_endpoint *grpc_transport_get_endpoint(grpc_exec_ctx *exec_ctx,
-                                           grpc_transport *transport) {
+grpc_endpoint* grpc_transport_get_endpoint(grpc_exec_ctx* exec_ctx,
+                                           grpc_transport* transport) {
   return transport->vtable->get_endpoint(exec_ctx, transport);
 }
 
@@ -214,8 +214,8 @@ grpc_endpoint *grpc_transport_get_endpoint(grpc_exec_ctx *exec_ctx,
 // though it lives in lib, it handles transport stream ops sure
 // it's grpc_transport_stream_op_batch_finish_with_failure
 void grpc_transport_stream_op_batch_finish_with_failure(
-    grpc_exec_ctx *exec_ctx, grpc_transport_stream_op_batch *batch,
-    grpc_error *error, grpc_call_combiner *call_combiner) {
+    grpc_exec_ctx* exec_ctx, grpc_transport_stream_op_batch* batch,
+    grpc_error* error, grpc_call_combiner* call_combiner) {
   if (batch->send_message) {
     grpc_byte_stream_destroy(exec_ctx,
                              batch->payload->send_message.send_message);
@@ -240,19 +240,19 @@ void grpc_transport_stream_op_batch_finish_with_failure(
 
 typedef struct {
   grpc_closure outer_on_complete;
-  grpc_closure *inner_on_complete;
+  grpc_closure* inner_on_complete;
   grpc_transport_op op;
 } made_transport_op;
 
-static void destroy_made_transport_op(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_error *error) {
-  made_transport_op *op = (made_transport_op *)arg;
+static void destroy_made_transport_op(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_error* error) {
+  made_transport_op* op = (made_transport_op*)arg;
   GRPC_CLOSURE_SCHED(exec_ctx, op->inner_on_complete, GRPC_ERROR_REF(error));
   gpr_free(op);
 }
 
-grpc_transport_op *grpc_make_transport_op(grpc_closure *on_complete) {
-  made_transport_op *op = (made_transport_op *)gpr_malloc(sizeof(*op));
+grpc_transport_op* grpc_make_transport_op(grpc_closure* on_complete) {
+  made_transport_op* op = (made_transport_op*)gpr_malloc(sizeof(*op));
   GRPC_CLOSURE_INIT(&op->outer_on_complete, destroy_made_transport_op, op,
                     grpc_schedule_on_exec_ctx);
   op->inner_on_complete = on_complete;
@@ -263,23 +263,23 @@ grpc_transport_op *grpc_make_transport_op(grpc_closure *on_complete) {
 
 typedef struct {
   grpc_closure outer_on_complete;
-  grpc_closure *inner_on_complete;
+  grpc_closure* inner_on_complete;
   grpc_transport_stream_op_batch op;
   grpc_transport_stream_op_batch_payload payload;
 } made_transport_stream_op;
 
-static void destroy_made_transport_stream_op(grpc_exec_ctx *exec_ctx, void *arg,
-                                             grpc_error *error) {
-  made_transport_stream_op *op = (made_transport_stream_op *)arg;
-  grpc_closure *c = op->inner_on_complete;
+static void destroy_made_transport_stream_op(grpc_exec_ctx* exec_ctx, void* arg,
+                                             grpc_error* error) {
+  made_transport_stream_op* op = (made_transport_stream_op*)arg;
+  grpc_closure* c = op->inner_on_complete;
   gpr_free(op);
   GRPC_CLOSURE_RUN(exec_ctx, c, GRPC_ERROR_REF(error));
 }
 
-grpc_transport_stream_op_batch *grpc_make_transport_stream_op(
-    grpc_closure *on_complete) {
-  made_transport_stream_op *op =
-      (made_transport_stream_op *)gpr_zalloc(sizeof(*op));
+grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
+    grpc_closure* on_complete) {
+  made_transport_stream_op* op =
+      (made_transport_stream_op*)gpr_zalloc(sizeof(*op));
   op->op.payload = &op->payload;
   GRPC_CLOSURE_INIT(&op->outer_on_complete, destroy_made_transport_stream_op,
                     op, grpc_schedule_on_exec_ctx);