grpc 1.7.3 → 1.8.0

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

@@ -43,41 +43,39 @@ typedef struct grpc_transport grpc_transport;
    for a stream. */
 typedef struct grpc_stream grpc_stream;
 
-#ifndef NDEBUG
-extern grpc_tracer_flag grpc_trace_stream_refcount;
-#endif
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount;
 
 typedef struct grpc_stream_refcount {
   gpr_refcount refs;
   grpc_closure destroy;
 #ifndef NDEBUG
-  const char *object_type;
+  const char* object_type;
 #endif
   grpc_slice_refcount slice_refcount;
 } grpc_stream_refcount;
 
 #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(grpc_stream_refcount *refcount, const char *reason);
-void grpc_stream_unref(grpc_exec_ctx *exec_ctx, grpc_stream_refcount *refcount,
-                       const char *reason);
+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(grpc_stream_refcount* refcount, const char* reason);
+void grpc_stream_unref(grpc_exec_ctx* exec_ctx, grpc_stream_refcount* refcount,
+                       const char* reason);
 #define GRPC_STREAM_REF_INIT(rc, ir, cb, cb_arg, objtype) \
   grpc_stream_ref_init(rc, ir, cb, cb_arg, objtype)
 #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(grpc_stream_refcount *refcount);
-void grpc_stream_unref(grpc_exec_ctx *exec_ctx, grpc_stream_refcount *refcount);
+void grpc_stream_ref_init(grpc_stream_refcount* refcount, int initial_refs,
+                          grpc_iomgr_cb_func cb, void* cb_arg);
+void grpc_stream_ref(grpc_stream_refcount* refcount);
+void grpc_stream_unref(grpc_exec_ctx* exec_ctx, grpc_stream_refcount* refcount);
 #define GRPC_STREAM_REF_INIT(rc, ir, cb, cb_arg, objtype) \
   grpc_stream_ref_init(rc, ir, cb, cb_arg)
 #endif
 
 /* Wrap a buffer that is owned by some stream object into a slice that shares
    the same refcount */
-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);
 
 typedef struct {
   uint64_t framing_bytes;
@@ -90,14 +88,14 @@ typedef struct grpc_transport_stream_stats {
   grpc_transport_one_way_stats outgoing;
 } grpc_transport_stream_stats;
 
-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);
 
-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);
 
 typedef struct {
-  void *extra_arg;
+  void* extra_arg;
   grpc_closure closure;
 } grpc_handler_private_op_data;
 
@@ -110,10 +108,10 @@ typedef struct grpc_transport_stream_op_batch {
   /** Should be enqueued when all requested operations (excluding recv_message
       and recv_initial_metadata which have their own closures) in a given batch
       have been completed. */
-  grpc_closure *on_complete;
+  grpc_closure* on_complete;
 
   /** Values for the stream op (fields set are determined by flags above) */
-  grpc_transport_stream_op_batch_payload *payload;
+  grpc_transport_stream_op_batch_payload* payload;
 
   /** Send initial metadata to the peer, from the provided metadata batch. */
   bool send_initial_metadata : 1;
@@ -149,17 +147,17 @@ typedef struct grpc_transport_stream_op_batch {
 
 struct grpc_transport_stream_op_batch_payload {
   struct {
-    grpc_metadata_batch *send_initial_metadata;
+    grpc_metadata_batch* send_initial_metadata;
     /** Iff send_initial_metadata != NULL, flags associated with
         send_initial_metadata: a bitfield of GRPC_INITIAL_METADATA_xxx */
     uint32_t send_initial_metadata_flags;
     // If non-NULL, will be set by the transport to the peer string
     // (a char*, which the caller takes ownership of).
-    gpr_atm *peer_string;
+    gpr_atm* peer_string;
   } send_initial_metadata;
 
   struct {
-    grpc_metadata_batch *send_trailing_metadata;
+    grpc_metadata_batch* send_trailing_metadata;
   } send_trailing_metadata;
 
   struct {
@@ -168,21 +166,21 @@ struct grpc_transport_stream_op_batch_payload {
     // grpc_byte_stream_destroy() on this.
     // The batch's on_complete will not be called until after the byte
     // stream is destroyed.
-    grpc_byte_stream *send_message;
+    grpc_byte_stream* send_message;
   } send_message;
 
   struct {
-    grpc_metadata_batch *recv_initial_metadata;
-    uint32_t *recv_flags;
+    grpc_metadata_batch* recv_initial_metadata;
+    uint32_t* recv_flags;
     /** Should be enqueued when initial metadata is ready to be processed. */
-    grpc_closure *recv_initial_metadata_ready;
+    grpc_closure* recv_initial_metadata_ready;
     // If not NULL, will be set to true if trailing metadata is
     // immediately available.  This may be a signal that we received a
     // Trailers-Only response.
-    bool *trailing_metadata_available;
+    bool* trailing_metadata_available;
     // If non-NULL, will be set by the transport to the peer string
     // (a char*, which the caller takes ownership of).
-    gpr_atm *peer_string;
+    gpr_atm* peer_string;
   } recv_initial_metadata;
 
   struct {
@@ -190,17 +188,17 @@ struct grpc_transport_stream_op_batch_payload {
     // containing a received message.
     // The caller is responsible for calling grpc_byte_stream_destroy()
     // on this byte stream.
-    grpc_byte_stream **recv_message;
+    grpc_byte_stream** recv_message;
     /** Should be enqueued when one message is ready to be processed. */
-    grpc_closure *recv_message_ready;
+    grpc_closure* recv_message_ready;
   } recv_message;
 
   struct {
-    grpc_metadata_batch *recv_trailing_metadata;
+    grpc_metadata_batch* recv_trailing_metadata;
   } recv_trailing_metadata;
 
   struct {
-    grpc_transport_stream_stats *collect_stats;
+    grpc_transport_stream_stats* collect_stats;
   } collect_stats;
 
   /** Forcefully close this stream.
@@ -216,43 +214,43 @@ struct grpc_transport_stream_op_batch_payload {
   struct {
     // Error contract: the transport that gets this op must cause cancel_error
     //                 to be unref'ed after processing it
-    grpc_error *cancel_error;
+    grpc_error* cancel_error;
   } cancel_stream;
 
   /* Indexes correspond to grpc_context_index enum values */
-  grpc_call_context_element *context;
+  grpc_call_context_element* context;
 };
 
 /** Transport op: a set of operations to perform on a transport as a whole */
 typedef struct grpc_transport_op {
   /** Called when processing of this op is done. */
-  grpc_closure *on_consumed;
+  grpc_closure* on_consumed;
   /** connectivity monitoring - set connectivity_state to NULL to unsubscribe */
-  grpc_closure *on_connectivity_state_change;
-  grpc_connectivity_state *connectivity_state;
+  grpc_closure* on_connectivity_state_change;
+  grpc_connectivity_state* connectivity_state;
   /** should the transport be disconnected
    * Error contract: the transport that gets this op must cause
    *                 disconnect_with_error to be unref'ed after processing it */
-  grpc_error *disconnect_with_error;
+  grpc_error* disconnect_with_error;
   /** what should the goaway contain?
    * Error contract: the transport that gets this op must cause
    *                 goaway_error to be unref'ed after processing it */
-  grpc_error *goaway_error;
+  grpc_error* goaway_error;
   /** set the callback for accepting new streams;
       this is a permanent callback, unlike the other one-shot closures.
       If true, the callback is set to set_accept_stream_fn, with its
       user_data argument set to set_accept_stream_user_data */
   bool set_accept_stream;
-  void (*set_accept_stream_fn)(grpc_exec_ctx *exec_ctx, void *user_data,
-                               grpc_transport *transport,
-                               const void *server_data);
-  void *set_accept_stream_user_data;
+  void (*set_accept_stream_fn)(grpc_exec_ctx* exec_ctx, void* user_data,
+                               grpc_transport* transport,
+                               const void* server_data);
+  void* set_accept_stream_user_data;
   /** add this transport to a pollset */
-  grpc_pollset *bind_pollset;
+  grpc_pollset* bind_pollset;
   /** add this transport to a pollset_set */
-  grpc_pollset_set *bind_pollset_set;
+  grpc_pollset_set* bind_pollset_set;
   /** send a ping, call this back if not NULL */
-  grpc_closure *send_ping;
+  grpc_closure* send_ping;
 
   /***************************************************************************
    * remaining fields are initialized and used at the discretion of the
@@ -263,7 +261,7 @@ typedef struct grpc_transport_op {
 
 /* Returns the amount of memory required to store a grpc_stream for this
    transport */
-size_t grpc_transport_stream_size(grpc_transport *transport);
+size_t grpc_transport_stream_size(grpc_transport* transport);
 
 /* Initialize transport data for a stream.
 
@@ -275,13 +273,13 @@ size_t grpc_transport_stream_size(grpc_transport *transport);
      stream      - a pointer to uninitialized memory to initialize
      server_data - either NULL for a client initiated stream, or a pointer
                    supplied from the accept_stream callback function */
-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);
 
-void grpc_transport_set_pops(grpc_exec_ctx *exec_ctx, grpc_transport *transport,
-                             grpc_stream *stream, grpc_polling_entity *pollent);
+void grpc_transport_set_pops(grpc_exec_ctx* exec_ctx, grpc_transport* transport,
+                             grpc_stream* stream, grpc_polling_entity* pollent);
 
 /* Destroy transport data for a stream.
 
@@ -293,17 +291,17 @@ void grpc_transport_set_pops(grpc_exec_ctx *exec_ctx, grpc_transport *transport,
      transport - the transport on which to create this stream
      stream    - the grpc_stream to destroy (memory is still owned by the
                  caller, but any child memory must be cleaned up) */
-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);
 
 void grpc_transport_stream_op_batch_finish_with_failure(
-    grpc_exec_ctx *exec_ctx, grpc_transport_stream_op_batch *op,
-    grpc_error *error, grpc_call_combiner *call_combiner);
+    grpc_exec_ctx* exec_ctx, grpc_transport_stream_op_batch* op,
+    grpc_error* error, grpc_call_combiner* call_combiner);
 
-char *grpc_transport_stream_op_batch_string(grpc_transport_stream_op_batch *op);
-char *grpc_transport_op_string(grpc_transport_op *op);
+char* grpc_transport_stream_op_batch_string(grpc_transport_stream_op_batch* op);
+char* grpc_transport_op_string(grpc_transport_op* op);
 
 /* Send a batch of operations on a transport
 
@@ -315,39 +313,39 @@ char *grpc_transport_op_string(grpc_transport_op *op);
                  non-NULL and previously initialized by the same transport.
      op        - a grpc_transport_stream_op_batch specifying the op to perform
    */
-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);
 
-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);
 
 /* Send a ping on a transport
 
    Calls cb with user data when a response is received. */
-void grpc_transport_ping(grpc_transport *transport, grpc_closure *cb);
+void grpc_transport_ping(grpc_transport* transport, grpc_closure* cb);
 
 /* Advise peer of pending connection termination. */
-void grpc_transport_goaway(grpc_transport *transport, grpc_status_code status,
+void grpc_transport_goaway(grpc_transport* transport, grpc_status_code status,
                            grpc_slice debug_data);
 
 /* Destroy the transport */
-void grpc_transport_destroy(grpc_exec_ctx *exec_ctx, grpc_transport *transport);
+void grpc_transport_destroy(grpc_exec_ctx* exec_ctx, grpc_transport* transport);
 
 /* Get the endpoint used by \a transport */
-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);
 
 /* Allocate a grpc_transport_op, and preconfigure the on_consumed closure to
    \a on_consumed and then delete the returned transport op */
-grpc_transport_op *grpc_make_transport_op(grpc_closure *on_consumed);
+grpc_transport_op* grpc_make_transport_op(grpc_closure* on_consumed);
 /* Allocate a grpc_transport_stream_op_batch, and preconfigure the on_consumed
    closure
    to \a on_consumed and then delete the returned transport op */
-grpc_transport_stream_op_batch *grpc_make_transport_stream_op(
-    grpc_closure *on_consumed);
+grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
+    grpc_closure* on_consumed);
 
 #ifdef __cplusplus
 }

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

@@ -21,52 +21,60 @@
 
 #include "src/core/lib/transport/transport.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_transport_vtable {
   /* Memory required for a single stream element - this is allocated by upper
      layers and initialized by the transport */
   size_t sizeof_stream; /* = sizeof(transport stream) */
 
   /* name of this transport implementation */
-  const char *name;
+  const char* name;
 
   /* implementation of grpc_transport_init_stream */
-  int (*init_stream)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                     grpc_stream *stream, grpc_stream_refcount *refcount,
-                     const void *server_data, gpr_arena *arena);
+  int (*init_stream)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                     grpc_stream* stream, grpc_stream_refcount* refcount,
+                     const void* server_data, gpr_arena* arena);
 
   /* implementation of grpc_transport_set_pollset */
-  void (*set_pollset)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                      grpc_stream *stream, grpc_pollset *pollset);
+  void (*set_pollset)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                      grpc_stream* stream, grpc_pollset* pollset);
 
   /* implementation of grpc_transport_set_pollset */
-  void (*set_pollset_set)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                          grpc_stream *stream, grpc_pollset_set *pollset_set);
+  void (*set_pollset_set)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                          grpc_stream* stream, grpc_pollset_set* pollset_set);
 
   /* implementation of grpc_transport_perform_stream_op */
-  void (*perform_stream_op)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                            grpc_stream *stream,
-                            grpc_transport_stream_op_batch *op);
+  void (*perform_stream_op)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                            grpc_stream* stream,
+                            grpc_transport_stream_op_batch* op);
 
   /* implementation of grpc_transport_perform_op */
-  void (*perform_op)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                     grpc_transport_op *op);
+  void (*perform_op)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                     grpc_transport_op* op);
 
   /* implementation of grpc_transport_destroy_stream */
-  void (*destroy_stream)(grpc_exec_ctx *exec_ctx, grpc_transport *self,
-                         grpc_stream *stream,
-                         grpc_closure *then_schedule_closure);
+  void (*destroy_stream)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
+                         grpc_stream* stream,
+                         grpc_closure* then_schedule_closure);
 
   /* implementation of grpc_transport_destroy */
-  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_transport *self);
+  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_transport* self);
 
   /* implementation of grpc_transport_get_endpoint */
-  grpc_endpoint *(*get_endpoint)(grpc_exec_ctx *exec_ctx, grpc_transport *self);
+  grpc_endpoint* (*get_endpoint)(grpc_exec_ctx* exec_ctx, grpc_transport* self);
 } grpc_transport_vtable;
 
 /* an instance of a grpc transport */
 struct grpc_transport {
   /* pointer to a vtable defining operations on this transport */
-  const grpc_transport_vtable *vtable;
+  const grpc_transport_vtable* vtable;
 };
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H */

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

@@ -16,8 +16,11 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_stack.h"
 
+#include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
@@ -32,7 +35,7 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-static void put_metadata(gpr_strvec *b, grpc_mdelem md) {
+static void put_metadata(gpr_strvec* b, grpc_mdelem md) {
   gpr_strvec_add(b, gpr_strdup("key="));
   gpr_strvec_add(
       b, grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII));
@@ -42,24 +45,23 @@ static void put_metadata(gpr_strvec *b, grpc_mdelem md) {
       b, grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII));
 }
 
-static void put_metadata_list(gpr_strvec *b, grpc_metadata_batch md) {
-  grpc_linked_mdelem *m;
-  for (m = md.list.head; m != NULL; m = m->next) {
+static void put_metadata_list(gpr_strvec* b, grpc_metadata_batch md) {
+  grpc_linked_mdelem* m;
+  for (m = md.list.head; m != nullptr; m = m->next) {
     if (m != md.list.head) gpr_strvec_add(b, gpr_strdup(", "));
     put_metadata(b, m->md);
   }
-  if (gpr_time_cmp(md.deadline, gpr_inf_future(md.deadline.clock_type)) != 0) {
-    char *tmp;
-    gpr_asprintf(&tmp, " deadline=%" PRId64 ".%09d", md.deadline.tv_sec,
-                 md.deadline.tv_nsec);
+  if (md.deadline != GRPC_MILLIS_INF_FUTURE) {
+    char* tmp;
+    gpr_asprintf(&tmp, " deadline=%" PRIdPTR, md.deadline);
     gpr_strvec_add(b, tmp);
   }
 }
 
-char *grpc_transport_stream_op_batch_string(
-    grpc_transport_stream_op_batch *op) {
-  char *tmp;
-  char *out;
+char* grpc_transport_stream_op_batch_string(
+    grpc_transport_stream_op_batch* op) {
+  char* tmp;
+  char* out;
 
   gpr_strvec b;
   gpr_strvec_init(&b);
@@ -105,7 +107,7 @@ char *grpc_transport_stream_op_batch_string(
 
   if (op->cancel_stream) {
     gpr_strvec_add(&b, gpr_strdup(" "));
-    const char *msg =
+    const char* msg =
         grpc_error_string(op->payload->cancel_stream.cancel_error);
     gpr_asprintf(&tmp, "CANCEL:%s", msg);
 
@@ -119,24 +121,24 @@ char *grpc_transport_stream_op_batch_string(
     gpr_strvec_add(&b, tmp);
   }
 
-  out = gpr_strvec_flatten(&b, NULL);
+  out = gpr_strvec_flatten(&b, nullptr);
   gpr_strvec_destroy(&b);
 
   return out;
 }
 
-char *grpc_transport_op_string(grpc_transport_op *op) {
-  char *tmp;
-  char *out;
+char* grpc_transport_op_string(grpc_transport_op* op) {
+  char* tmp;
+  char* out;
   bool first = true;
 
   gpr_strvec b;
   gpr_strvec_init(&b);
 
-  if (op->on_connectivity_state_change != NULL) {
+  if (op->on_connectivity_state_change != nullptr) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     first = false;
-    if (op->connectivity_state != NULL) {
+    if (op->connectivity_state != nullptr) {
       gpr_asprintf(&tmp, "ON_CONNECTIVITY_STATE_CHANGE:p=%p:from=%s",
                    op->on_connectivity_state_change,
                    grpc_connectivity_state_name(*op->connectivity_state));
@@ -151,7 +153,7 @@ char *grpc_transport_op_string(grpc_transport_op *op) {
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     first = false;
-    const char *err = grpc_error_string(op->disconnect_with_error);
+    const char* err = grpc_error_string(op->disconnect_with_error);
     gpr_asprintf(&tmp, "DISCONNECT:%s", err);
     gpr_strvec_add(&b, tmp);
   }
@@ -159,7 +161,7 @@ char *grpc_transport_op_string(grpc_transport_op *op) {
   if (op->goaway_error) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     first = false;
-    const char *msg = grpc_error_string(op->goaway_error);
+    const char* msg = grpc_error_string(op->goaway_error);
     gpr_asprintf(&tmp, "SEND_GOAWAY:%s", msg);
 
     gpr_strvec_add(&b, tmp);
@@ -173,34 +175,34 @@ char *grpc_transport_op_string(grpc_transport_op *op) {
     gpr_strvec_add(&b, tmp);
   }
 
-  if (op->bind_pollset != NULL) {
+  if (op->bind_pollset != nullptr) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     first = false;
     gpr_strvec_add(&b, gpr_strdup("BIND_POLLSET"));
   }
 
-  if (op->bind_pollset_set != NULL) {
+  if (op->bind_pollset_set != nullptr) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     first = false;
     gpr_strvec_add(&b, gpr_strdup("BIND_POLLSET_SET"));
   }
 
-  if (op->send_ping != NULL) {
+  if (op->send_ping != nullptr) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
-    first = false;
+    // first = false;
     gpr_strvec_add(&b, gpr_strdup("SEND_PING"));
   }
 
-  out = gpr_strvec_flatten(&b, NULL);
+  out = gpr_strvec_flatten(&b, nullptr);
   gpr_strvec_destroy(&b);
 
   return out;
 }
 
-void grpc_call_log_op(const char *file, int line, gpr_log_severity severity,
-                      grpc_call_element *elem,
-                      grpc_transport_stream_op_batch *op) {
-  char *str = grpc_transport_stream_op_batch_string(op);
+void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
+                      grpc_call_element* elem,
+                      grpc_transport_stream_op_batch* op) {
+  char* str = grpc_transport_stream_op_batch_string(op);
   gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem, str);
   gpr_free(str);
 }