grpc 1.51.0 → 1.52.0.pre2

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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 2018 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>
 
@@ -28,6 +28,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -53,59 +54,59 @@ struct recv_message_result {
 
 typedef struct alts_grpc_handshaker_client {
   alts_handshaker_client base;
-  /* One ref is held by the entity that created this handshaker_client, and
-   * another ref is held by the pending RECEIVE_STATUS_ON_CLIENT op. */
+  // One ref is held by the entity that created this handshaker_client, and
+  // another ref is held by the pending RECEIVE_STATUS_ON_CLIENT op.
   gpr_refcount refs;
   alts_tsi_handshaker* handshaker;
   grpc_call* call;
-  /* A pointer to a function handling the interaction with handshaker service.
-   * That is, it points to grpc_call_start_batch_and_execute when the handshaker
-   * client is used in a non-testing use case and points to a custom function
-   * that validates the data to be sent to handshaker service in a testing use
-   * case. */
+  // A pointer to a function handling the interaction with handshaker service.
+  // That is, it points to grpc_call_start_batch_and_execute when the handshaker
+  // client is used in a non-testing use case and points to a custom function
+  // that validates the data to be sent to handshaker service in a testing use
+  // case.
   alts_grpc_caller grpc_caller;
-  /* A gRPC closure to be scheduled when the response from handshaker service
-   * is received. It will be initialized with the injected grpc RPC callback. */
+  // A gRPC closure to be scheduled when the response from handshaker service
+  // is received. It will be initialized with the injected grpc RPC callback.
   grpc_closure on_handshaker_service_resp_recv;
-  /* Buffers containing information to be sent (or received) to (or from) the
-   * handshaker service. */
+  // Buffers containing information to be sent (or received) to (or from) the
+  // handshaker service.
   grpc_byte_buffer* send_buffer = nullptr;
   grpc_byte_buffer* recv_buffer = nullptr;
   // Used to inject a read failure from tests.
   bool inject_read_failure = false;
-  /* Initial metadata to be received from handshaker service. */
+  // Initial metadata to be received from handshaker service.
   grpc_metadata_array recv_initial_metadata;
-  /* A callback function provided by an application to be invoked when response
-   * is received from handshaker service. */
+  // A callback function provided by an application to be invoked when response
+  // is received from handshaker service.
   tsi_handshaker_on_next_done_cb cb;
   void* user_data;
-  /* ALTS credential options passed in from the caller. */
+  // ALTS credential options passed in from the caller.
   grpc_alts_credentials_options* options;
-  /* target name information to be passed to handshaker service for server
-   * authorization check. */
+  // target name information to be passed to handshaker service for server
+  // authorization check.
   grpc_slice target_name;
-  /* boolean flag indicating if the handshaker client is used at client
-   * (is_client = true) or server (is_client = false) side. */
+  // boolean flag indicating if the handshaker client is used at client
+  // (is_client = true) or server (is_client = false) side.
   bool is_client;
-  /* a temporary store for data received from handshaker service used to extract
-   * unused data. */
+  // a temporary store for data received from handshaker service used to extract
+  // unused data.
   grpc_slice recv_bytes;
-  /* a buffer containing data to be sent to the grpc client or server's peer. */
+  // a buffer containing data to be sent to the grpc client or server's peer.
   unsigned char* buffer;
   size_t buffer_size;
-  /** callback for receiving handshake call status */
+  /// callback for receiving handshake call status
   grpc_closure on_status_received;
-  /** gRPC status code of handshake call */
+  /// gRPC status code of handshake call
   grpc_status_code handshake_status_code = GRPC_STATUS_OK;
-  /** gRPC status details of handshake call */
+  /// gRPC status details of handshake call
   grpc_slice handshake_status_details;
-  /* mu synchronizes all fields below including their internal fields. */
+  // mu synchronizes all fields below including their internal fields.
   grpc_core::Mutex mu;
-  /* indicates if the handshaker call's RECV_STATUS_ON_CLIENT op is done. */
+  // indicates if the handshaker call's RECV_STATUS_ON_CLIENT op is done.
   bool receive_status_finished = false;
-  /* if non-null, contains arguments to complete a TSI next callback. */
+  // if non-null, contains arguments to complete a TSI next callback.
   recv_message_result* pending_recv_message_result = nullptr;
-  /* Maximum frame size used by frame protector. */
+  // Maximum frame size used by frame protector.
   size_t max_frame_size;
   // If non-null, will be populated with an error string upon error.
   std::string* error;
@@ -198,7 +199,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   grpc_byte_buffer* recv_buffer = client->recv_buffer;
   alts_tsi_handshaker* handshaker = client->handshaker;
-  /* Invalid input check. */
+  // Invalid input check.
   if (client->cb == nullptr) {
     gpr_log(GPR_ERROR,
             "client->cb is nullptr in alts_tsi_handshaker_handle_response()");
@@ -213,14 +214,14 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
         nullptr, 0, nullptr);
     return;
   }
-  /* TSI handshake has been shutdown. */
+  // TSI handshake has been shutdown.
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
     gpr_log(GPR_INFO, "TSI handshake shutdown");
     handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN,
                          "TSI handshake shutdown", nullptr, 0, nullptr);
     return;
   }
-  /* Check for failed grpc read. */
+  // Check for failed grpc read.
   if (!is_ok || client->inject_read_failure) {
     gpr_log(GPR_INFO, "read failed on grpc call to handshaker service");
     handle_response_done(client, TSI_INTERNAL_ERROR,
@@ -242,7 +243,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
       alts_tsi_utils_deserialize_response(recv_buffer, arena.ptr());
   grpc_byte_buffer_destroy(client->recv_buffer);
   client->recv_buffer = nullptr;
-  /* Invalid handshaker response check. */
+  // Invalid handshaker response check.
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "alts_tsi_utils_deserialize_response() failed");
     handle_response_done(client, TSI_DATA_CORRUPTED,
@@ -406,14 +407,14 @@ class HandshakeQueue {
 };
 
 gpr_once g_queued_handshakes_init = GPR_ONCE_INIT;
-/* Using separate queues for client and server handshakes is a
- * hack that's mainly intended to satisfy the alts_concurrent_connectivity_test,
- * which runs many concurrent handshakes where both endpoints
- * are in the same process; this situation is problematic with a
- * single queue because we have a high chance of using up all outstanding
- * slots in the queue, such that there aren't any
- * mutual client/server handshakes outstanding at the same time and
- * able to make progress. */
+// Using separate queues for client and server handshakes is a
+// hack that's mainly intended to satisfy the alts_concurrent_connectivity_test,
+// which runs many concurrent handshakes where both endpoints
+// are in the same process; this situation is problematic with a
+// single queue because we have a high chance of using up all outstanding
+// slots in the queue, such that there aren't any
+// mutual client/server handshakes outstanding at the same time and
+// able to make progress.
 HandshakeQueue* g_client_handshake_queue;
 HandshakeQueue* g_server_handshake_queue;
 
@@ -440,10 +441,10 @@ void HandshakeDone(bool is_client) {
 
 };  // namespace
 
-/**
- * Populate grpc operation data with the fields of ALTS handshaker client and
- * make a grpc call.
- */
+///
+/// Populate grpc operation data with the fields of ALTS handshaker client and
+/// make a grpc call.
+///
 static tsi_result make_grpc_call(alts_handshaker_client* c, bool is_start) {
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
@@ -477,8 +478,8 @@ static void on_status_received(void* arg, grpc_error_handle error) {
   alts_grpc_handshaker_client_unref(client);
 }
 
-/* Serializes a grpc_gcp_HandshakerReq message into a buffer and returns newly
- * grpc_byte_buffer holding it. */
+// Serializes a grpc_gcp_HandshakerReq message into a buffer and returns newly
+// grpc_byte_buffer holding it.
 static grpc_byte_buffer* get_serialized_handshaker_req(
     grpc_gcp_HandshakerReq* req, upb_Arena* arena) {
   size_t buf_length;
@@ -492,7 +493,7 @@ static grpc_byte_buffer* get_serialized_handshaker_req(
   return byte_buffer;
 }
 
-/* Create and populate a client_start handshaker request, then serialize it. */
+// Create and populate a client_start handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_start_client(
     alts_handshaker_client* c) {
   GPR_ASSERT(c != nullptr);
@@ -557,7 +558,7 @@ static tsi_result handshaker_client_start_client(alts_handshaker_client* c) {
   return result;
 }
 
-/* Create and populate a start_server handshaker request, then serialize it. */
+// Create and populate a start_server handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_start_server(
     alts_handshaker_client* c, grpc_slice* bytes_received) {
   GPR_ASSERT(c != nullptr);
@@ -616,7 +617,7 @@ static tsi_result handshaker_client_start_server(alts_handshaker_client* c,
   return result;
 }
 
-/* Create and populate a next handshaker request, then serialize it. */
+// Create and populate a next handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_next(grpc_slice* bytes_received) {
   GPR_ASSERT(bytes_received != nullptr);
   upb::Arena arena;

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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 2018 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_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
@@ -38,19 +38,19 @@
 const size_t kAltsAes128GcmRekeyKeyLength = 44;
 
 typedef struct alts_tsi_handshaker alts_tsi_handshaker;
-/**
- * A ALTS handshaker client interface. It is used to communicate with
- * ALTS handshaker service by scheduling a handshaker request that could be one
- * of client_start, server_start, and next handshaker requests. All APIs in the
- * header are thread-compatible.
- */
+///
+/// A ALTS handshaker client interface. It is used to communicate with
+/// ALTS handshaker service by scheduling a handshaker request that could be one
+/// of client_start, server_start, and next handshaker requests. All APIs in the
+/// header are thread-compatible.
+///
 typedef struct alts_handshaker_client alts_handshaker_client;
 
-/* A function that makes the grpc call to the handshaker service. */
+// A function that makes the grpc call to the handshaker service.
 typedef grpc_call_error (*alts_grpc_caller)(grpc_call* call, const grpc_op* ops,
                                             size_t nops, grpc_closure* tag);
 
-/* V-table for ALTS handshaker client operations. */
+// V-table for ALTS handshaker client operations.
 typedef struct alts_handshaker_client_vtable {
   tsi_result (*client_start)(alts_handshaker_client* client);
   tsi_result (*server_start)(alts_handshaker_client* client,
@@ -61,83 +61,83 @@ typedef struct alts_handshaker_client_vtable {
   void (*destruct)(alts_handshaker_client* client);
 } alts_handshaker_client_vtable;
 
-/**
- * This method schedules a client_start handshaker request to ALTS handshaker
- * service.
- *
- * - client: ALTS handshaker client instance.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a client_start handshaker request to ALTS handshaker
+/// service.
+///
+///- client: ALTS handshaker client instance.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_start_client(alts_handshaker_client* client);
 
-/**
- * This method schedules a server_start handshaker request to ALTS handshaker
- * service.
- *
- * - client: ALTS handshaker client instance.
- * - bytes_received: bytes in out_frames returned from the peer's handshaker
- *   response.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a server_start handshaker request to ALTS handshaker
+/// service.
+///
+///- client: ALTS handshaker client instance.
+///- bytes_received: bytes in out_frames returned from the peer's handshaker
+///  response.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_start_server(alts_handshaker_client* client,
                                                grpc_slice* bytes_received);
 
-/**
- * This method schedules a next handshaker request to ALTS handshaker service.
- *
- * - client: ALTS handshaker client instance.
- * - bytes_received: bytes in out_frames returned from the peer's handshaker
- *   response.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a next handshaker request to ALTS handshaker service.
+///
+///- client: ALTS handshaker client instance.
+///- bytes_received: bytes in out_frames returned from the peer's handshaker
+///  response.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_next(alts_handshaker_client* client,
                                        grpc_slice* bytes_received);
 
-/**
- * This method cancels previously scheduled, but yet executed handshaker
- * requests to ALTS handshaker service. After this operation, the handshake
- * will be shutdown, and no more handshaker requests will get scheduled.
- *
- * - client: ALTS handshaker client instance.
- */
+///
+/// This method cancels previously scheduled, but yet executed handshaker
+/// requests to ALTS handshaker service. After this operation, the handshake
+/// will be shutdown, and no more handshaker requests will get scheduled.
+///
+///- client: ALTS handshaker client instance.
+///
 void alts_handshaker_client_shutdown(alts_handshaker_client* client);
 
-/**
- * This method destroys an ALTS handshaker client.
- *
- * - client: an ALTS handshaker client instance.
- */
+///
+/// This method destroys an ALTS handshaker client.
+///
+///- client: an ALTS handshaker client instance.
+///
 void alts_handshaker_client_destroy(alts_handshaker_client* client);
 
-/**
- * This method creates an ALTS handshaker client.
- *
- * - handshaker: ALTS TSI handshaker to which the created handshaker client
- *   belongs to.
- * - channel: grpc channel to ALTS handshaker service.
- * - handshaker_service_url: address of ALTS handshaker service in the format of
- *   "host:port".
- * - interested_parties: set of pollsets interested in this connection.
- * - options: ALTS credentials options containing information passed from TSI
- *   caller (e.g., rpc protocol versions)
- * - target_name: the name of the endpoint that the channel is connecting to,
- *   and will be used for secure naming check
- * - grpc_cb: gRPC provided callbacks passed from TSI handshaker.
- * - cb: callback to be executed when tsi_handshaker_next API compltes.
- * - user_data: argument passed to cb.
- * - vtable_for_testing: ALTS handshaker client vtable instance used for
- *   testing purpose.
- * - is_client: a boolean value indicating if the created handshaker client is
- *   used at the client (is_client = true) or server (is_client = false) side.
- * - max_frame_size: Maximum frame size used by frame protector (User specified
- *   maximum frame size if present or default max frame size).
- *
- * It returns the created ALTS handshaker client on success, and NULL
- * on failure.
- */
+///
+/// This method creates an ALTS handshaker client.
+///
+///- handshaker: ALTS TSI handshaker to which the created handshaker client
+///  belongs to.
+///- channel: grpc channel to ALTS handshaker service.
+///- handshaker_service_url: address of ALTS handshaker service in the format of
+///  "host:port".
+///- interested_parties: set of pollsets interested in this connection.
+///- options: ALTS credentials options containing information passed from TSI
+///  caller (e.g., rpc protocol versions)
+///- target_name: the name of the endpoint that the channel is connecting to,
+///  and will be used for secure naming check
+///- grpc_cb: gRPC provided callbacks passed from TSI handshaker.
+///- cb: callback to be executed when tsi_handshaker_next API compltes.
+///- user_data: argument passed to cb.
+///- vtable_for_testing: ALTS handshaker client vtable instance used for
+///  testing purpose.
+///- is_client: a boolean value indicating if the created handshaker client is
+///  used at the client (is_client = true) or server (is_client = false) side.
+///- max_frame_size: Maximum frame size used by frame protector (User specified
+///  maximum frame size if present or default max frame size).
+///
+/// It returns the created ALTS handshaker client on success, and NULL
+/// on failure.
+///
 alts_handshaker_client* alts_grpc_handshaker_client_create(
     alts_tsi_handshaker* handshaker, grpc_channel* channel,
     const char* handshaker_service_url, grpc_pollset_set* interested_parties,
@@ -146,15 +146,15 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
     bool is_client, size_t max_frame_size, std::string* error);
 
-/**
- * This method handles handshaker response returned from ALTS handshaker
- * service. Note that the only reason the API is exposed is that it is used in
- * alts_shared_resources.cc.
- *
- * - client: an ALTS handshaker client instance.
- * - is_ok: a boolean value indicating if the handshaker response is ok to read.
- */
+///
+/// This method handles handshaker response returned from ALTS handshaker
+/// service. Note that the only reason the API is exposed is that it is used in
+/// alts_shared_resources.cc.
+///
+///- client: an ALTS handshaker client instance.
+///- is_ok: a boolean value indicating if the handshaker response is ok to read.
+///
 void alts_handshaker_client_handle_response(alts_handshaker_client* client,
                                             bool is_ok);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H */
+#endif  // GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H

data/src/core/tsi/alts/handshaker/alts_shared_resource.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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 2018 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>
 
@@ -23,6 +23,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
 static alts_shared_resource_dedicated g_alts_resource_dedicated;

data/src/core/tsi/alts/handshaker/alts_shared_resource.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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 2018 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_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
@@ -28,10 +28,10 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/surface/completion_queue.h"
 
-/**
- * Main struct containing ALTS shared resources used when
- * employing the dedicated completion queue and thread.
- */
+///
+/// Main struct containing ALTS shared resources used when
+/// employing the dedicated completion queue and thread.
+///
 typedef struct alts_shared_resource_dedicated {
   grpc_core::Thread thread;
   grpc_completion_queue* cq;
@@ -41,33 +41,32 @@ typedef struct alts_shared_resource_dedicated {
   grpc_channel* channel;
 } alts_shared_resource_dedicated;
 
-/* This method returns the address of alts_shared_resource_dedicated
- * object shared by all TSI handshakes.
- */
+// This method returns the address of alts_shared_resource_dedicated
+// object shared by all TSI handshakes.
+//
 alts_shared_resource_dedicated* grpc_alts_get_shared_resource_dedicated(void);
 
-/**
- * This method destroys the alts_shared_resource_dedicated object
- * shared by all TSI handshakes. The application is responsible for
- * invoking the API before calling grpc_shutdown().
- */
+///
+/// This method destroys the alts_shared_resource_dedicated object
+/// shared by all TSI handshakes. The application is responsible for
+/// invoking the API before calling grpc_shutdown().
+///
 void grpc_alts_shared_resource_dedicated_shutdown();
 
-/**
- * This method initializes the alts_shared_resource_dedicated object
- * shared by all TSI handshakes. The application is responsible for
- * invoking the API after calling grpc_init();
- */
+///
+/// This method initializes the alts_shared_resource_dedicated object
+/// shared by all TSI handshakes. The application is responsible for
+/// invoking the API after calling grpc_init();
+///
 void grpc_alts_shared_resource_dedicated_init();
 
-/**
- * This method populates various fields of the alts_shared_resource_dedicated
- * object shared by all TSI handshakes and start the dedicated thread.
- * The API will be invoked by the caller in a lazy manner. That is,
- * it will get invoked when ALTS TSI handshake occurs for the first time.
- */
+///
+/// This method populates various fields of the alts_shared_resource_dedicated
+/// object shared by all TSI handshakes and start the dedicated thread.
+/// The API will be invoked by the caller in a lazy manner. That is,
+/// it will get invoked when ALTS TSI handshake occurs for the first time.
+///
 void grpc_alts_shared_resource_dedicated_start(
     const char* handshaker_service_url);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H \
-        */
+#endif  // GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H