grpc 1.51.0 → 1.52.0

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H
 #define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H
@@ -33,11 +33,12 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
@@ -60,7 +61,7 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport_fwd.h"
 
-/* Minimum and maximum protocol accepted versions. */
+// Minimum and maximum protocol accepted versions.
 #define GRPC_PROTOCOL_VERSION_MAX_MAJOR 2
 #define GRPC_PROTOCOL_VERSION_MAX_MINOR 1
 #define GRPC_PROTOCOL_VERSION_MIN_MAJOR 2
@@ -68,14 +69,14 @@
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
-/** Internal bit flag for grpc_begin_message's \a flags signaling the use of
- * compression for the message. (Does not apply for stream compression.) */
+/// Internal bit flag for grpc_begin_message's \a flags signaling the use of
+/// compression for the message. (Does not apply for stream compression.)
 #define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
-/** Internal bit flag for determining whether the message was compressed and had
- * to be decompressed by the message_decompress filter. (Does not apply for
- * stream compression.) */
+/// Internal bit flag for determining whether the message was compressed and had
+/// to be decompressed by the message_decompress filter. (Does not apply for
+/// stream compression.)
 #define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
-/** Mask of all valid internal flags. */
+/// Mask of all valid internal flags.
 #define GRPC_WRITE_INTERNAL_USED_MASK \
   (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
 
@@ -156,11 +157,11 @@ using NextPromiseFactory =
 
 }  // namespace grpc_core
 
-/* forward declarations */
+// forward declarations
 
-/* grpc_stream doesn't actually exist. It's used as a typesafe
-   opaque pointer for whatever data the transport wants to track
-   for a stream. */
+// grpc_stream doesn't actually exist. It's used as a typesafe
+// opaque pointer for whatever data the transport wants to track
+// for a stream.
 typedef struct grpc_stream grpc_stream;
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount;
@@ -225,8 +226,8 @@ inline void grpc_stream_unref(grpc_stream_refcount* refcount) {
 }
 #endif
 
-/* Wrap a buffer that is owned by some stream object into a slice that shares
-   the same refcount */
+// 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);
 
@@ -239,6 +240,7 @@ struct grpc_transport_one_way_stats {
 struct grpc_transport_stream_stats {
   grpc_transport_one_way_stats incoming;
   grpc_transport_one_way_stats outgoing;
+  gpr_timespec latency = gpr_inf_future(GPR_TIMESPAN);
 };
 
 void grpc_transport_move_one_way_stats(grpc_transport_one_way_stats* from,
@@ -269,8 +271,8 @@ struct grpc_handler_private_op_data {
 typedef struct grpc_transport_stream_op_batch_payload
     grpc_transport_stream_op_batch_payload;
 
-/* Transport stream op: a set of operations to perform on a transport
-   against a single stream */
+// Transport stream op: a set of operations to perform on a transport
+// against a single stream
 struct grpc_transport_stream_op_batch {
   grpc_transport_stream_op_batch()
       : send_initial_metadata(false),
@@ -282,48 +284,48 @@ struct grpc_transport_stream_op_batch {
         cancel_stream(false),
         is_traced(false) {}
 
-  /** Should be scheduled when all of the non-recv operations in the batch
-      are complete.
+  /// Should be scheduled when all of the non-recv operations in the batch
+  /// are complete.
 
-      The recv ops (recv_initial_metadata, recv_message, and
-      recv_trailing_metadata) each have their own callbacks.  If a batch
-      contains both recv ops and non-recv ops, on_complete should be
-      scheduled as soon as the non-recv ops are complete, regardless of
-      whether or not the recv ops are complete.  If a batch contains
-      only recv ops, on_complete can be null. */
+  /// The recv ops (recv_initial_metadata, recv_message, and
+  /// recv_trailing_metadata) each have their own callbacks.  If a batch
+  /// contains both recv ops and non-recv ops, on_complete should be
+  /// scheduled as soon as the non-recv ops are complete, regardless of
+  /// whether or not the recv ops are complete.  If a batch contains
+  /// only recv ops, on_complete can be null.
   grpc_closure* on_complete = nullptr;
 
-  /** Values for the stream op (fields set are determined by flags above) */
+  /// Values for the stream op (fields set are determined by flags above)
   grpc_transport_stream_op_batch_payload* payload = nullptr;
 
-  /** Send initial metadata to the peer, from the provided metadata batch. */
+  /// Send initial metadata to the peer, from the provided metadata batch.
   bool send_initial_metadata : 1;
 
-  /** Send trailing metadata to the peer, from the provided metadata batch. */
+  /// Send trailing metadata to the peer, from the provided metadata batch.
   bool send_trailing_metadata : 1;
 
-  /** Send message data to the peer, from the provided byte stream. */
+  /// Send message data to the peer, from the provided byte stream.
   bool send_message : 1;
 
-  /** Receive initial metadata from the stream, into provided metadata batch. */
+  /// Receive initial metadata from the stream, into provided metadata batch.
   bool recv_initial_metadata : 1;
 
-  /** Receive message data from the stream, into provided byte stream. */
+  /// Receive message data from the stream, into provided byte stream.
   bool recv_message : 1;
 
-  /** Receive trailing metadata from the stream, into provided metadata batch.
-   */
+  /// Receive trailing metadata from the stream, into provided metadata batch.
+  ///
   bool recv_trailing_metadata : 1;
 
-  /** Cancel this stream with the provided error */
+  /// Cancel this stream with the provided error
   bool cancel_stream : 1;
 
-  /** Is this stream traced */
+  /// Is this stream traced
   bool is_traced : 1;
 
-  /***************************************************************************
-   * remaining fields are initialized and used at the discretion of the
-   * current handler of the op */
+  //**************************************************************************
+  // remaining fields are initialized and used at the discretion of the
+  // current handler of the op
 
   grpc_handler_private_op_data handler_private;
 };
@@ -375,7 +377,7 @@ struct grpc_transport_stream_op_batch_payload {
 
   struct {
     grpc_metadata_batch* recv_initial_metadata = nullptr;
-    /** Should be enqueued when initial metadata is ready to be processed. */
+    /// Should be enqueued when initial metadata is ready to be processed.
     grpc_closure* recv_initial_metadata_ready = nullptr;
     // If not NULL, will be set to true if trailing metadata is
     // immediately available. This may be a signal that we received a
@@ -400,108 +402,108 @@ struct grpc_transport_stream_op_batch_payload {
     uint32_t* flags = nullptr;
     // Was this recv_message failed for reasons other than a clean end-of-stream
     bool* call_failed_before_recv_message = nullptr;
-    /** Should be enqueued when one message is ready to be processed. */
+    /// Should be enqueued when one message is ready to be processed.
     grpc_closure* recv_message_ready = nullptr;
   } recv_message;
 
   struct {
     grpc_metadata_batch* recv_trailing_metadata = nullptr;
     grpc_transport_stream_stats* collect_stats = nullptr;
-    /** Should be enqueued when trailing metadata is ready to be processed. */
+    /// Should be enqueued when trailing metadata is ready to be processed.
     grpc_closure* recv_trailing_metadata_ready = nullptr;
   } recv_trailing_metadata;
 
-  /** Forcefully close this stream.
-      The HTTP2 semantics should be:
-      - server side: if cancel_error has
-     grpc_core::StatusIntProperty::kRpcStatus, and trailing metadata has not
-     been sent, send trailing metadata with status and message from cancel_error
-     (use grpc_error_get_status) followed by a RST_STREAM with
-     error=GRPC_CHTTP2_NO_ERROR to force a full close
-      - at all other times: use grpc_error_get_status to get a status code, and
-        convert to a HTTP2 error code using
-        grpc_chttp2_grpc_status_to_http2_error. Send a RST_STREAM with this
-        error. */
+  /// Forcefully close this stream.
+  /// The HTTP2 semantics should be:
+  /// - server side: if cancel_error has
+  /// grpc_core::StatusIntProperty::kRpcStatus, and trailing metadata has not
+  /// been sent, send trailing metadata with status and message from
+  /// cancel_error (use grpc_error_get_status) followed by a RST_STREAM with
+  /// error=GRPC_CHTTP2_NO_ERROR to force a full close
+  /// - at all other times: use grpc_error_get_status to get a status code, and
+  ///   convert to a HTTP2 error code using
+  ///   grpc_chttp2_grpc_status_to_http2_error. Send a RST_STREAM with this
+  ///   error.
   struct {
     // Error contract: the transport that gets this op must cause cancel_error
     //                 to be unref'ed after processing it
     grpc_error_handle cancel_error;
   } cancel_stream;
 
-  /* Indexes correspond to grpc_context_index enum values */
+  // Indexes correspond to grpc_context_index enum values
   grpc_call_context_element* context;
 };
 
-/** Transport op: a set of operations to perform on a transport as a whole */
+/// 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. */
+  /// Called when processing of this op is done.
   grpc_closure* on_consumed = nullptr;
-  /** connectivity monitoring - set connectivity_state to NULL to unsubscribe */
+  /// connectivity monitoring - set connectivity_state to NULL to unsubscribe
   grpc_core::OrphanablePtr<grpc_core::ConnectivityStateWatcherInterface>
       start_connectivity_watch;
   grpc_connectivity_state start_connectivity_watch_state = GRPC_CHANNEL_IDLE;
   grpc_core::ConnectivityStateWatcherInterface* stop_connectivity_watch =
       nullptr;
-  /** 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 */
+  /// 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_handle 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 */
+  /// 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_handle 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 */
+  /// 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 = false;
   void (*set_accept_stream_fn)(void* user_data, grpc_transport* transport,
                                const void* server_data) = nullptr;
   void* set_accept_stream_user_data = nullptr;
-  /** set the callback for accepting new streams based upon promises;
-      this is a permanent callback, unlike the other one-shot closures.
-      If true, the callback is set to set_make_promise_fn, with its
-      user_data argument set to set_make_promise_data */
+  /// set the callback for accepting new streams based upon promises;
+  /// this is a permanent callback, unlike the other one-shot closures.
+  /// If true, the callback is set to set_make_promise_fn, with its
+  /// user_data argument set to set_make_promise_data
   bool set_make_promise = false;
   void (*set_make_promise_fn)(void* user_data, grpc_transport* transport,
                               const void* server_data) = nullptr;
   void* set_make_promise_user_data = nullptr;
-  /** add this transport to a pollset */
+  /// add this transport to a pollset
   grpc_pollset* bind_pollset = nullptr;
-  /** add this transport to a pollset_set */
+  /// add this transport to a pollset_set
   grpc_pollset_set* bind_pollset_set = nullptr;
-  /** send a ping, if either on_initiate or on_ack is not NULL */
+  /// send a ping, if either on_initiate or on_ack is not NULL
   struct {
-    /** Ping may be delayed by the transport, on_initiate callback will be
-        called when the ping is actually being sent. */
+    /// Ping may be delayed by the transport, on_initiate callback will be
+    /// called when the ping is actually being sent.
     grpc_closure* on_initiate = nullptr;
-    /** Called when the ping ack is received */
+    /// Called when the ping ack is received
     grpc_closure* on_ack = nullptr;
   } send_ping;
   // If true, will reset the channel's connection backoff.
   bool reset_connect_backoff = false;
 
-  /***************************************************************************
-   * remaining fields are initialized and used at the discretion of the
-   * transport implementation */
+  //**************************************************************************
+  // remaining fields are initialized and used at the discretion of the
+  // transport implementation
 
   grpc_handler_private_op_data handler_private;
 } grpc_transport_op;
 
-/* Returns the amount of memory required to store a grpc_stream for this
-   transport */
+// Returns the amount of memory required to store a grpc_stream for this
+// transport
 size_t grpc_transport_stream_size(grpc_transport* transport);
 
-/* Initialize transport data for a stream.
+// Initialize transport data for a stream.
 
-   Returns 0 on success, any other (transport-defined) value for failure.
-   May assume that stream contains all-zeros.
+// Returns 0 on success, any other (transport-defined) value for failure.
+// May assume that stream contains all-zeros.
 
-   Arguments:
-     transport   - the transport on which to create this stream
-     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 */
+// Arguments:
+//   transport   - the transport on which to create this stream
+//   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_transport* transport, grpc_stream* stream,
                                grpc_stream_refcount* refcount,
                                const void* server_data,
@@ -510,16 +512,16 @@ int grpc_transport_init_stream(grpc_transport* transport, grpc_stream* stream,
 void grpc_transport_set_pops(grpc_transport* transport, grpc_stream* stream,
                              grpc_polling_entity* pollent);
 
-/* Destroy transport data for a stream.
+// Destroy transport data for a stream.
 
-   Requires: a recv_batch with final_state == GRPC_STREAM_CLOSED has been
-   received by the up-layer. Must not be called in the same call stack as
-   recv_frame.
+// Requires: a recv_batch with final_state == GRPC_STREAM_CLOSED has been
+// received by the up-layer. Must not be called in the same call stack as
+// recv_frame.
 
-   Arguments:
-     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) */
+// Arguments:
+//   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_transport* transport,
                                    grpc_stream* stream,
                                    grpc_closure* then_schedule_closure);
@@ -539,16 +541,16 @@ std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op);
 std::string grpc_transport_op_string(grpc_transport_op* op);
 
-/* Send a batch of operations on a transport
+// Send a batch of operations on a transport
 
-   Takes ownership of any objects contained in ops.
+// Takes ownership of any objects contained in ops.
 
-   Arguments:
-     transport - the transport on which to initiate the stream
-     stream    - the stream on which to send the operations. This must be
-                 non-NULL and previously initialized by the same transport.
-     op        - a grpc_transport_stream_op_batch specifying the op to perform
-   */
+// Arguments:
+//   transport - the transport on which to initiate the stream
+//   stream    - the stream on which to send the operations. This must be
+//               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_transport* transport,
                                       grpc_stream* stream,
                                       grpc_transport_stream_op_batch* op);
@@ -556,27 +558,27 @@ void grpc_transport_perform_stream_op(grpc_transport* transport,
 void grpc_transport_perform_op(grpc_transport* transport,
                                grpc_transport_op* op);
 
-/* Send a ping on a transport
+// Send a ping on a transport
 
-   Calls cb with user data when a response is received. */
+// Calls cb with user data when a response is received.
 void grpc_transport_ping(grpc_transport* transport, grpc_closure* cb);
 
-/* Advise peer of pending connection termination. */
+// Advise peer of pending connection termination.
 void grpc_transport_goaway(grpc_transport* transport, grpc_status_code status,
                            grpc_slice debug_data);
 
-/* Destroy the transport */
+// Destroy the transport
 void grpc_transport_destroy(grpc_transport* transport);
 
-/* Get the endpoint used by \a transport */
+// Get the endpoint used by \a transport
 grpc_endpoint* grpc_transport_get_endpoint(grpc_transport* transport);
 
-/* Allocate a grpc_transport_op, and preconfigure the on_complete closure to
-   \a on_complete and then delete the returned transport op */
+// Allocate a grpc_transport_op, and preconfigure the on_complete closure to
+// \a on_complete and then delete the returned transport op
 grpc_transport_op* grpc_make_transport_op(grpc_closure* on_complete);
-/* Allocate a grpc_transport_stream_op_batch, and preconfigure the on_complete
-   closure
-   to \a on_complete and then delete the returned transport op */
+// Allocate a grpc_transport_stream_op_batch, and preconfigure the on_complete
+// closure
+// to \a on_complete and then delete the returned transport op
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
     grpc_closure* on_complete);
 
@@ -587,4 +589,4 @@ constexpr const char* kKeepaliveThrottlingKey =
     "grpc.internal.keepalive_throttling";
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H */
+#endif  // GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H
 #define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H
@@ -34,62 +34,62 @@
 #include "src/core/lib/transport/transport_fwd.h"
 
 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) */
+  // 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 */
+  // name of this transport implementation
   const char* name;
 
-  /* implementation of grpc_transport_init_stream */
+  // implementation of grpc_transport_init_stream
   int (*init_stream)(grpc_transport* self, grpc_stream* stream,
                      grpc_stream_refcount* refcount, const void* server_data,
                      grpc_core::Arena* arena);
 
-  /* Create a promise to execute one client call.
-     If this is non-null, it may be used in preference to
-     perform_stream_op.
-     If this is used in preference to perform_stream_op, the
-     following can be omitted also:
-       - calling init_stream, destroy_stream, set_pollset, set_pollset_set
-       - allocation of memory for call data (sizeof_stream may be ignored)
-     There is an on-going migration to move all filters to providing this, and
-     then to drop perform_stream_op. */
+  // Create a promise to execute one client call.
+  // If this is non-null, it may be used in preference to
+  // perform_stream_op.
+  // If this is used in preference to perform_stream_op, the
+  // following can be omitted also:
+  //   - calling init_stream, destroy_stream, set_pollset, set_pollset_set
+  //   - allocation of memory for call data (sizeof_stream may be ignored)
+  // There is an on-going migration to move all filters to providing this, and
+  // then to drop perform_stream_op.
   grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
       grpc_transport* self, grpc_core::CallArgs call_args);
 
-  /* implementation of grpc_transport_set_pollset */
+  // implementation of grpc_transport_set_pollset
   void (*set_pollset)(grpc_transport* self, grpc_stream* stream,
                       grpc_pollset* pollset);
 
-  /* implementation of grpc_transport_set_pollset */
+  // implementation of grpc_transport_set_pollset
   void (*set_pollset_set)(grpc_transport* self, grpc_stream* stream,
                           grpc_pollset_set* pollset_set);
 
-  /* implementation of grpc_transport_perform_stream_op */
+  // implementation of grpc_transport_perform_stream_op
   void (*perform_stream_op)(grpc_transport* self, grpc_stream* stream,
                             grpc_transport_stream_op_batch* op);
 
-  /* implementation of grpc_transport_perform_op */
+  // implementation of grpc_transport_perform_op
   void (*perform_op)(grpc_transport* self, grpc_transport_op* op);
 
-  /* implementation of grpc_transport_destroy_stream */
+  // implementation of grpc_transport_destroy_stream
   void (*destroy_stream)(grpc_transport* self, grpc_stream* stream,
                          grpc_closure* then_schedule_closure);
 
-  /* implementation of grpc_transport_destroy */
+  // implementation of grpc_transport_destroy
   void (*destroy)(grpc_transport* self);
 
-  /* implementation of grpc_transport_get_endpoint */
+  // implementation of grpc_transport_get_endpoint
   grpc_endpoint* (*get_endpoint)(grpc_transport* self);
 } grpc_transport_vtable;
 
-/* an instance of a grpc transport */
+// an instance of a grpc transport
 struct grpc_transport {
   struct RawPointerChannelArgTag {};
   static absl::string_view ChannelArgName() { return GRPC_ARG_TRANSPORT; }
-  /* pointer to a vtable defining operations on this transport */
+  // pointer to a vtable defining operations on this transport
   const grpc_transport_vtable* vtable;
 };
 
-#endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H */
+#endif  // GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H

data/src/core/lib/transport/transport_op_string.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -39,8 +39,8 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
-/* These routines are here to facilitate debugging - they produce string
-   representations of various transport data structures */
+// These routines are here to facilitate debugging - they produce string
+// representations of various transport data structures
 
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op) {