grpc 1.50.0 → 1.52.0.pre2

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

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.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>
 
@@ -33,6 +33,7 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
@@ -45,7 +46,7 @@
 #include "src/core/tsi/alts/handshaker/alts_tsi_utils.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.h"
 
-/* Main struct for ALTS TSI handshaker. */
+// Main struct for ALTS TSI handshaker.
 struct alts_tsi_handshaker {
   tsi_handshaker base;
   grpc_slice target_name;
@@ -71,7 +72,7 @@ struct alts_tsi_handshaker {
   size_t max_frame_size;
 };
 
-/* Main struct for ALTS TSI handshaker result. */
+// Main struct for ALTS TSI handshaker result.
 typedef struct alts_tsi_handshaker_result {
   tsi_handshaker_result base;
   char* peer_identity;
@@ -249,8 +250,8 @@ static void handshaker_result_destroy(tsi_handshaker_result* self) {
   gpr_free(result->peer_identity);
   gpr_free(result->key_data);
   gpr_free(result->unused_bytes);
-  grpc_slice_unref_internal(result->rpc_versions);
-  grpc_slice_unref_internal(result->serialized_context);
+  grpc_core::CSliceUnref(result->rpc_versions);
+  grpc_core::CSliceUnref(result->serialized_context);
   gpr_free(result);
 }
 
@@ -382,7 +383,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
   return TSI_OK;
 }
 
-/* gRPC provided callback used when gRPC thread model is applied. */
+// gRPC provided callback used when gRPC thread model is applied.
 static void on_handshaker_service_resp_recv(void* arg,
                                             grpc_error_handle error) {
   alts_handshaker_client* client = static_cast<alts_handshaker_client*>(arg);
@@ -391,28 +392,28 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     success = false;
   }
   alts_handshaker_client_handle_response(client, success);
 }
 
-/* gRPC provided callback used when dedicatd CQ and thread are used.
- * It serves to safely bring the control back to application. */
+// gRPC provided callback used when dedicatd CQ and thread are used.
+// It serves to safely bring the control back to application.
 static void on_handshaker_service_resp_recv_dedicated(
     void* arg, grpc_error_handle /*error*/) {
   alts_shared_resource_dedicated* resource =
       grpc_alts_get_shared_resource_dedicated();
   grpc_cq_end_op(
-      resource->cq, arg, GRPC_ERROR_NONE,
+      resource->cq, arg, absl::OkStatus(),
       [](void* /*done_arg*/, grpc_cq_completion* /*storage*/) {}, nullptr,
       &resource->storage);
 }
 
-/* Returns TSI_OK if and only if no error is encountered. */
+// Returns TSI_OK if and only if no error is encountered.
 static tsi_result alts_tsi_handshaker_continue_handshaker_next(
     alts_tsi_handshaker* handshaker, const unsigned char* received_bytes,
     size_t received_bytes_size, tsi_handshaker_on_next_done_cb cb,
@@ -481,7 +482,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
   } else {
     ok = alts_handshaker_client_next(handshaker->client, &slice);
   }
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   return ok;
 }
 
@@ -563,7 +564,7 @@ static tsi_result handshaker_next(
     // stack. Doing so avoids potential lock cycles between g_init_mu and other
     // mutexes within core that might be held on the current call stack
     // (note that g_init_mu gets acquired during channel creation).
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, absl::OkStatus());
   } else {
     tsi_result ok = alts_tsi_handshaker_continue_handshaker_next(
         handshaker, received_bytes, received_bytes_size, cb, user_data, error);
@@ -575,11 +576,11 @@ static tsi_result handshaker_next(
   return TSI_ASYNC;
 }
 
-/*
- * This API will be invoked by a non-gRPC application, and an ExecCtx needs
- * to be explicitly created in order to invoke ALTS handshaker client API's
- * that assumes the caller is inside gRPC core.
- */
+//
+// This API will be invoked by a non-gRPC application, and an ExecCtx needs
+// to be explicitly created in order to invoke ALTS handshaker client API's
+// that assumes the caller is inside gRPC core.
+//
 static tsi_result handshaker_next_dedicated(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** bytes_to_send,
@@ -612,7 +613,7 @@ static void handshaker_destroy(tsi_handshaker* self) {
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
   alts_handshaker_client_destroy(handshaker->client);
-  grpc_slice_unref_internal(handshaker->target_name);
+  grpc_core::CSliceUnref(handshaker->target_name);
   grpc_alts_credentials_options_destroy(handshaker->options);
   if (handshaker->channel != nullptr) {
     grpc_channel_destroy_internal(handshaker->channel);

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.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_TSI_HANDSHAKER_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_H
@@ -45,60 +45,60 @@ const size_t kTsiAltsMaxFrameSize = 1024 * 1024;
 
 typedef struct alts_tsi_handshaker alts_tsi_handshaker;
 
-/**
- * This method creates a ALTS TSI handshaker instance.
- *
- * - 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.
- * - handshaker_service_url: address of ALTS handshaker service in the format of
- *   "host:port".
- * - is_client: boolean value indicating if the handshaker is used at the client
- *   (is_client = true) or server (is_client = false) side.
- * - interested_parties: set of pollsets interested in this connection.
- * - self: address of ALTS TSI handshaker instance to be returned from the
- *   method.
- * - user_specified_max_frame_size: Determines the maximum frame size used by
- *   frame protector that is specified via user. If unspecified, the value is 0.
- *
- * It returns TSI_OK on success and an error status code on failure. Note that
- * if interested_parties is nullptr, a dedicated TSI thread will be created and
- * used.
- */
+///
+/// This method creates a ALTS TSI handshaker instance.
+///
+///- 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.
+///- handshaker_service_url: address of ALTS handshaker service in the format of
+///  "host:port".
+///- is_client: boolean value indicating if the handshaker is used at the client
+///  (is_client = true) or server (is_client = false) side.
+///- interested_parties: set of pollsets interested in this connection.
+///- self: address of ALTS TSI handshaker instance to be returned from the
+///  method.
+///- user_specified_max_frame_size: Determines the maximum frame size used by
+///  frame protector that is specified via user. If unspecified, the value is 0.
+///
+/// It returns TSI_OK on success and an error status code on failure. Note that
+/// if interested_parties is nullptr, a dedicated TSI thread will be created and
+/// used.
+///
 tsi_result alts_tsi_handshaker_create(
     const grpc_alts_credentials_options* options, const char* target_name,
     const char* handshaker_service_url, bool is_client,
     grpc_pollset_set* interested_parties, tsi_handshaker** self,
     size_t user_specified_max_frame_size);
 
-/**
- * This method creates an ALTS TSI handshaker result instance.
- *
- * - resp: data received from the handshaker service.
- * - is_client: a boolean value indicating if the result belongs to a
- *   client or not.
- * - result: address of ALTS TSI handshaker result instance.
- */
+///
+/// This method creates an ALTS TSI handshaker result instance.
+///
+///- resp: data received from the handshaker service.
+///- is_client: a boolean value indicating if the result belongs to a
+///  client or not.
+///- result: address of ALTS TSI handshaker result instance.
+///
 tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
                                              bool is_client,
                                              tsi_handshaker_result** result);
 
-/**
- * This method sets unused bytes of ALTS TSI handshaker result instance.
- *
- * - result: an ALTS TSI handshaker result instance.
- * - recv_bytes: data received from the handshaker service.
- * - bytes_consumed: size of data consumed by the handshaker service.
- */
+///
+/// This method sets unused bytes of ALTS TSI handshaker result instance.
+///
+///- result: an ALTS TSI handshaker result instance.
+///- recv_bytes: data received from the handshaker service.
+///- bytes_consumed: size of data consumed by the handshaker service.
+///
 void alts_tsi_handshaker_result_set_unused_bytes(tsi_handshaker_result* result,
                                                  grpc_slice* recv_bytes,
                                                  size_t bytes_consumed);
 
-/**
- * This method returns a boolean value indicating if an ALTS TSI handshaker
- * has been shutdown or not.
- */
+///
+/// This method returns a boolean value indicating if an ALTS TSI handshaker
+/// has been shutdown or not.
+///
 bool alts_tsi_handshaker_has_shutdown(alts_tsi_handshaker* handshaker);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_H */
+#endif  // GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_H

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker_private.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_TSI_HANDSHAKER_PRIVATE_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_PRIVATE_H
@@ -26,8 +26,8 @@
 namespace grpc_core {
 namespace internal {
 
-/**
- * Unsafe, use for testing only. */
+///
+/// Unsafe, use for testing only.
 
 alts_handshaker_client* alts_tsi_handshaker_get_client_for_testing(
     alts_tsi_handshaker* handshaker);
@@ -86,4 +86,4 @@ void alts_handshaker_client_ref_for_testing(alts_handshaker_client* c);
 }  // namespace internal
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_PRIVATE_H */
+#endif  // GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_HANDSHAKER_PRIVATE_H

data/src/core/tsi/alts/handshaker/alts_tsi_utils.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>
 
@@ -22,6 +22,7 @@
 
 #include <grpc/byte_buffer_reader.h>
 
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
@@ -48,13 +49,13 @@ grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
   grpc_byte_buffer_reader bbr;
   grpc_byte_buffer_reader_init(&bbr, resp_buffer);
   grpc_slice slice = grpc_byte_buffer_reader_readall(&bbr);
-  size_t buf_size = GPR_SLICE_LENGTH(slice);
+  size_t buf_size = GRPC_SLICE_LENGTH(slice);
   void* buf = upb_Arena_Malloc(arena, buf_size);
-  memcpy(buf, reinterpret_cast<const char*>(GPR_SLICE_START_PTR(slice)),
+  memcpy(buf, reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
          buf_size);
   grpc_gcp_HandshakerResp* resp = grpc_gcp_HandshakerResp_parse(
       reinterpret_cast<char*>(buf), buf_size, arena);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   grpc_byte_buffer_reader_destroy(&bbr);
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "grpc_gcp_handshaker_resp_decode() failed");

data/src/core/tsi/alts/handshaker/alts_tsi_utils.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_TSI_UTILS_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_UTILS_H
@@ -27,27 +27,27 @@
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/proto/grpc/gcp/handshaker.upb.h"
 
-/**
- * This method converts grpc_status_code code to the corresponding tsi_result
- * code.
- *
- * - code: grpc_status_code code.
- *
- * It returns the converted tsi_result code.
- */
+///
+/// This method converts grpc_status_code code to the corresponding tsi_result
+/// code.
+///
+///- code: grpc_status_code code.
+///
+/// It returns the converted tsi_result code.
+///
 tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code);
 
-/**
- * This method deserializes a handshaker response returned from ALTS handshaker
- * service.
- *
- * - bytes_received: data returned from ALTS handshaker service.
- * - arena: upb arena.
- *
- * It returns a deserialized handshaker response on success and nullptr on
- * failure.
- */
+///
+/// This method deserializes a handshaker response returned from ALTS handshaker
+/// service.
+///
+///- bytes_received: data returned from ALTS handshaker service.
+///- arena: upb arena.
+///
+/// It returns a deserialized handshaker response on success and nullptr on
+/// failure.
+///
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
     grpc_byte_buffer* resp_buffer, upb_Arena* arena);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_UTILS_H */
+#endif  // GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_UTILS_H