grpc 1.46.3 → 1.53.1

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.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,34 +23,36 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
 
-/* Privacy-integrity alts_grpc_record_protocol object uses the same struct
- * defined in alts_grpc_record_protocol_common.h.  */
+// Privacy-integrity alts_grpc_record_protocol object uses the same struct
+// defined in alts_grpc_record_protocol_common.h.
 
-/* --- alts_grpc_record_protocol methods implementation. --- */
+// --- alts_grpc_record_protocol methods implementation. ---
 
 static tsi_result alts_grpc_privacy_integrity_protect(
     alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
-  /* Input sanity check.  */
+  // Input sanity check.
   if (rp == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
             "Invalid nullptr arguments to alts_grpc_record_protocol protect.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* Allocates memory for output frame. In privacy-integrity protect, the
-   * protected frame is stored in a newly allocated buffer.  */
+  // Allocates memory for output frame. In privacy-integrity protect, the
+  // protected frame is stored in a newly allocated buffer.
   size_t protected_frame_size =
       unprotected_slices->length + rp->header_length +
       alts_iovec_record_protocol_get_tag_length(rp->iovec_rp);
   grpc_slice protected_slice = GRPC_SLICE_MALLOC(protected_frame_size);
   iovec_t protected_iovec = {GRPC_SLICE_START_PTR(protected_slice),
                              GRPC_SLICE_LENGTH(protected_slice)};
-  /* Calls alts_iovec_record_protocol protect.  */
+  // Calls alts_iovec_record_protocol protect.
   char* error_details = nullptr;
   alts_grpc_record_protocol_convert_slice_buffer_to_iovec(rp,
                                                           unprotected_slices);
@@ -61,18 +63,18 @@ static tsi_result alts_grpc_privacy_integrity_protect(
   if (status != GRPC_STATUS_OK) {
     gpr_log(GPR_ERROR, "Failed to protect, %s", error_details);
     gpr_free(error_details);
-    grpc_slice_unref_internal(protected_slice);
+    grpc_core::CSliceUnref(protected_slice);
     return TSI_INTERNAL_ERROR;
   }
   grpc_slice_buffer_add(protected_slices, protected_slice);
-  grpc_slice_buffer_reset_and_unref_internal(unprotected_slices);
+  grpc_slice_buffer_reset_and_unref(unprotected_slices);
   return TSI_OK;
 }
 
 static tsi_result alts_grpc_privacy_integrity_unprotect(
     alts_grpc_record_protocol* rp, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices) {
-  /* Input sanity check.  */
+  // Input sanity check.
   if (rp == nullptr || protected_slices == nullptr ||
       unprotected_slices == nullptr) {
     gpr_log(
@@ -80,8 +82,8 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
         "Invalid nullptr arguments to alts_grpc_record_protocol unprotect.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* Allocates memory for output frame. In privacy-integrity unprotect, the
-   * unprotected data are stored in a newly allocated buffer.  */
+  // Allocates memory for output frame. In privacy-integrity unprotect, the
+  // unprotected data are stored in a newly allocated buffer.
   if (protected_slices->length < rp->header_length + rp->tag_length) {
     gpr_log(GPR_ERROR, "Protected slices do not have sufficient data.");
     return TSI_INVALID_ARGUMENT;
@@ -91,12 +93,12 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   grpc_slice unprotected_slice = GRPC_SLICE_MALLOC(unprotected_frame_size);
   iovec_t unprotected_iovec = {GRPC_SLICE_START_PTR(unprotected_slice),
                                GRPC_SLICE_LENGTH(unprotected_slice)};
-  /* Strips frame header from protected slices.  */
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
+  // Strips frame header from protected slices.
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
                                &rp->header_sb);
   iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp);
-  /* Calls alts_iovec_record_protocol unprotect.  */
+  // Calls alts_iovec_record_protocol unprotect.
   char* error_details = nullptr;
   alts_grpc_record_protocol_convert_slice_buffer_to_iovec(rp, protected_slices);
   grpc_status_code status =
@@ -106,11 +108,11 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   if (status != GRPC_STATUS_OK) {
     gpr_log(GPR_ERROR, "Failed to unprotect, %s", error_details);
     gpr_free(error_details);
-    grpc_slice_unref_internal(unprotected_slice);
+    grpc_core::CSliceUnref(unprotected_slice);
     return TSI_INTERNAL_ERROR;
   }
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
-  grpc_slice_buffer_reset_and_unref_internal(protected_slices);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(protected_slices);
   grpc_slice_buffer_add(unprotected_slices, unprotected_slice);
   return TSI_OK;
 }
@@ -130,7 +132,7 @@ tsi_result alts_grpc_privacy_integrity_record_protocol_create(
   }
   auto* impl = static_cast<alts_grpc_record_protocol*>(
       gpr_zalloc(sizeof(alts_grpc_record_protocol)));
-  /* Calls alts_grpc_record_protocol init.  */
+  // Calls alts_grpc_record_protocol init.
   tsi_result result =
       alts_grpc_record_protocol_init(impl, crypter, overflow_size, is_client,
                                      /*is_integrity_only=*/false, is_protect);

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.h

@@ -1,23 +1,23 @@
-/*
- *
- * 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_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
-#define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
+#ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
+#define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,24 +26,23 @@
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"
 
-/**
- * This method creates a privacy-integrity alts_grpc_record_protocol instance,
- * given a gsec_aead_crypter instance and a flag indicating if the created
- * instance will be used at the client or server side. The ownership of
- * gsec_aead_crypter instance is transferred to this new object.
- *
- * - crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
- * - is_client: a flag indicating if the alts_grpc_record_protocol instance will
- *   be used at the client or server side.
- * - rp: an alts_grpc_record_protocol instance to be returned from
- *   the method.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This method creates a privacy-integrity alts_grpc_record_protocol instance,
+/// given a gsec_aead_crypter instance and a flag indicating if the created
+/// instance will be used at the client or server side. The ownership of
+/// gsec_aead_crypter instance is transferred to this new object.
+///
+///- crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
+///- is_client: a flag indicating if the alts_grpc_record_protocol instance will
+///  be used at the client or server side.
+///- rp: an alts_grpc_record_protocol instance to be returned from
+///  the method.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_privacy_integrity_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_protect, alts_grpc_record_protocol** rp);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h

@@ -1,23 +1,23 @@
-/*
- *
- * 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_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
-#define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
+#ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
+#define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,67 +25,66 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-/**
- * This alts_grpc_record_protocol object protects and unprotects a single frame
- * stored in grpc slice buffer with zero or minimized memory copy.
- * Implementations of this object must be thread compatible.
- */
+///
+/// This alts_grpc_record_protocol object protects and unprotects a single frame
+/// stored in grpc slice buffer with zero or minimized memory copy.
+/// Implementations of this object must be thread compatible.
+///
 typedef struct alts_grpc_record_protocol alts_grpc_record_protocol;
 
-/**
- * This methods performs protect operation on unprotected data and appends the
- * protected frame to protected_slices. The caller needs to ensure the length
- * of unprotected data plus the frame overhead is less than or equal to the
- * maximum frame length. The input unprotected data slice buffer will be
- * cleared, although the actual unprotected data bytes are not modified.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - unprotected_slices: the unprotected data to be protected.
- * - protected_slices: slice buffer where the protected frame is appended.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This methods performs protect operation on unprotected data and appends the
+/// protected frame to protected_slices. The caller needs to ensure the length
+/// of unprotected data plus the frame overhead is less than or equal to the
+/// maximum frame length. The input unprotected data slice buffer will be
+/// cleared, although the actual unprotected data bytes are not modified.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- unprotected_slices: the unprotected data to be protected.
+///- protected_slices: slice buffer where the protected frame is appended.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_record_protocol_protect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices);
 
-/**
- * This methods performs unprotect operation on a full frame of protected data
- * and appends unprotected data to unprotected_slices. It is the caller's
- * responsibility to prepare a full frame of data before calling this method.
- * The input protected frame slice buffer will be cleared, although the actual
- * protected data bytes are not modified.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - protected_slices: a full frame of protected data in grpc slices.
- * - unprotected_slices: slice buffer where unprotected data is appended.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This methods performs unprotect operation on a full frame of protected data
+/// and appends unprotected data to unprotected_slices. It is the caller's
+/// responsibility to prepare a full frame of data before calling this method.
+/// The input protected frame slice buffer will be cleared, although the actual
+/// protected data bytes are not modified.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- protected_slices: a full frame of protected data in grpc slices.
+///- unprotected_slices: slice buffer where unprotected data is appended.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_record_protocol_unprotect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices);
 
-/**
- * This method returns maximum allowed unprotected data size, given maximum
- * protected frame size.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - max_protected_frame_size: maximum protected frame size.
- *
- * On success, the method returns the maximum allowed unprotected data size.
- * Otherwise, it returns zero.
- */
+///
+/// This method returns maximum allowed unprotected data size, given maximum
+/// protected frame size.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- max_protected_frame_size: maximum protected frame size.
+///
+/// On success, the method returns the maximum allowed unprotected data size.
+/// Otherwise, it returns zero.
+///
 size_t alts_grpc_record_protocol_max_unprotected_data_size(
     const alts_grpc_record_protocol* self, size_t max_protected_frame_size);
 
-/**
- * This method destroys an alts_grpc_record_protocol instance by de-allocating
- * all of its occupied memory.
- */
+///
+/// This method destroys an alts_grpc_record_protocol instance by de-allocating
+/// all of its occupied memory.
+///
 void alts_grpc_record_protocol_destroy(alts_grpc_record_protocol* self);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.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>
 
@@ -26,26 +26,27 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 const size_t kInitialIovecBufferSize = 8;
 
-/* Makes sure iovec_buf in alts_grpc_record_protocol is large enough.  */
+// Makes sure iovec_buf in alts_grpc_record_protocol is large enough.
 static void ensure_iovec_buf_size(alts_grpc_record_protocol* rp,
                                   const grpc_slice_buffer* sb) {
   GPR_ASSERT(rp != nullptr && sb != nullptr);
   if (sb->count <= rp->iovec_buf_length) {
     return;
   }
-  /* At least double the iovec buffer size.  */
+  // At least double the iovec buffer size.
   rp->iovec_buf_length = std::max(sb->count, 2 * rp->iovec_buf_length);
   rp->iovec_buf = static_cast<iovec_t*>(
       gpr_realloc(rp->iovec_buf, rp->iovec_buf_length * sizeof(iovec_t)));
 }
 
-/* --- Implementation of methods defined in tsi_grpc_record_protocol_common.h.
- * --- */
+// --- Implementation of methods defined in tsi_grpc_record_protocol_common.h.
+// ---
 
 void alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
     alts_grpc_record_protocol* rp, const grpc_slice_buffer* sb) {
@@ -77,8 +78,8 @@ iovec_t alts_grpc_record_protocol_get_header_iovec(
   if (rp->header_sb.count == 1) {
     header_iovec.iov_base = GRPC_SLICE_START_PTR(rp->header_sb.slices[0]);
   } else {
-    /* Frame header is in multiple slices, copies the header bytes from slice
-     * buffer to a single flat buffer.  */
+    // Frame header is in multiple slices, copies the header bytes from slice
+    // buffer to a single flat buffer.
     alts_grpc_record_protocol_copy_slice_buffer(&rp->header_sb, rp->header_buf);
     header_iovec.iov_base = rp->header_buf;
   }
@@ -95,7 +96,7 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
             "Invalid nullptr arguments to alts_grpc_record_protocol init.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* Creates alts_iovec_record_protocol.  */
+  // Creates alts_iovec_record_protocol.
   char* error_details = nullptr;
   grpc_status_code status = alts_iovec_record_protocol_create(
       crypter, overflow_size, is_client, is_integrity_only, is_protect,
@@ -106,20 +107,20 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  /* Allocates header slice buffer.  */
+  // Allocates header slice buffer.
   grpc_slice_buffer_init(&rp->header_sb);
-  /* Allocates header buffer.  */
+  // Allocates header buffer.
   rp->header_length = alts_iovec_record_protocol_get_header_length();
   rp->header_buf = static_cast<unsigned char*>(gpr_malloc(rp->header_length));
   rp->tag_length = alts_iovec_record_protocol_get_tag_length(rp->iovec_rp);
-  /* Allocates iovec buffer.  */
+  // Allocates iovec buffer.
   rp->iovec_buf_length = kInitialIovecBufferSize;
   rp->iovec_buf =
       static_cast<iovec_t*>(gpr_malloc(rp->iovec_buf_length * sizeof(iovec_t)));
   return TSI_OK;
 }
 
-/* --- Implementation of methods defined in tsi_grpc_record_protocol.h. --- */
+// --- Implementation of methods defined in tsi_grpc_record_protocol.h. ---
 tsi_result alts_grpc_record_protocol_protect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
@@ -156,14 +157,14 @@ void alts_grpc_record_protocol_destroy(alts_grpc_record_protocol* self) {
     self->vtable->destruct(self);
   }
   alts_iovec_record_protocol_destroy(self->iovec_rp);
-  grpc_slice_buffer_destroy_internal(&self->header_sb);
+  grpc_slice_buffer_destroy(&self->header_sb);
   gpr_free(self->header_buf);
   gpr_free(self->iovec_buf);
   gpr_free(self);
 }
 
-/* Integrity-only and privacy-integrity share the same implementation. No need
- * to call vtable.  */
+// Integrity-only and privacy-integrity share the same implementation. No need
+// to call vtable.
 size_t alts_grpc_record_protocol_max_unprotected_data_size(
     const alts_grpc_record_protocol* self, size_t max_protected_frame_size) {
   if (self == nullptr) {