grpc 1.51.0 → 1.52.0

data/src/core/lib/slice/b64.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_SLICE_B64_H
 #define GRPC_CORE_LIB_SLICE_B64_H
@@ -25,28 +25,28 @@
 
 #include <grpc/slice.h>
 
-/* Encodes data using base64. It is the caller's responsibility to free
-   the returned char * using gpr_free. Returns NULL on NULL input.
-   TODO(makdharma) : change the flags to bool from int */
+// Encodes data using base64. It is the caller's responsibility to free
+// the returned char * using gpr_free. Returns NULL on NULL input.
+// TODO(makdharma) : change the flags to bool from int
 char* grpc_base64_encode(const void* data, size_t data_size, int url_safe,
                          int multiline);
 
-/* estimate the upper bound on size of base64 encoded data. The actual size
- * is guaranteed to be less than or equal to the size returned here. */
+// estimate the upper bound on size of base64 encoded data. The actual size
+// is guaranteed to be less than or equal to the size returned here.
 size_t grpc_base64_estimate_encoded_size(size_t data_size, int multiline);
 
-/* Encodes data using base64 and write it to memory pointed to by result. It is
- * the caller's responsibility to allocate enough memory in |result| to fit the
- * encoded data. */
+// Encodes data using base64 and write it to memory pointed to by result. It is
+// the caller's responsibility to allocate enough memory in |result| to fit the
+// encoded data.
 void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
                              int url_safe, int multiline);
 
-/* Decodes data according to the base64 specification. Returns an empty
-   slice in case of failure. */
+// Decodes data according to the base64 specification. Returns an empty
+// slice in case of failure.
 grpc_slice grpc_base64_decode(const char* b64, int url_safe);
 
-/* Same as above except that the length is provided by the caller. */
+// Same as above except that the length is provided by the caller.
 grpc_slice grpc_base64_decode_with_len(const char* b64, size_t b64_len,
                                        int url_safe);
 
-#endif /* GRPC_CORE_LIB_SLICE_B64_H */
+#endif  // GRPC_CORE_LIB_SLICE_B64_H

data/src/core/lib/slice/percent_encoding.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 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 2016 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>
 

data/src/core/lib/slice/percent_encoding.h

@@ -1,30 +1,30 @@
-/*
- *
- * Copyright 2016 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 2016 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_SLICE_PERCENT_ENCODING_H
 #define GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H
 
-/* Percent encoding and decoding of slices.
-   Transforms arbitrary strings into safe-for-transmission strings by using
-   variants of percent encoding (RFC 3986).
-   Two major variants are supplied: one that strictly matches URL encoding,
-     and another which applies percent encoding only to non-http2 header
-     bytes (the 'compatible' variant) */
+// Percent encoding and decoding of slices.
+// Transforms arbitrary strings into safe-for-transmission strings by using
+// variants of percent encoding (RFC 3986).
+// Two major variants are supplied: one that strictly matches URL encoding,
+//   and another which applies percent encoding only to non-http2 header
+//   bytes (the 'compatible' variant)
 
 #include <grpc/support/port_platform.h>
 
@@ -51,4 +51,4 @@ Slice PermissivePercentDecodeSlice(Slice slice_in);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */
+#endif  // GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H

data/src/core/lib/slice/slice.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>
 
@@ -52,8 +52,8 @@ grpc_slice grpc_slice_copy(grpc_slice s) {
 
 namespace grpc_core {
 
-/* grpc_slice_new support structures - we create a refcount object extended
-   with the user provided data pointer & destroy function */
+// grpc_slice_new support structures - we create a refcount object extended
+// with the user provided data pointer & destroy function
 class NewSliceRefcount : public grpc_slice_refcount {
  public:
   NewSliceRefcount(void (*destroy)(void*), void* user_data)
@@ -101,13 +101,13 @@ grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
 }
 
 grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)) {
-  /* Pass "p" to *destroy when the slice is no longer needed. */
+  // Pass "p" to *destroy when the slice is no longer needed.
   return grpc_slice_new_with_user_data(p, len, destroy, p);
 }
 
 namespace grpc_core {
-/* grpc_slice_new_with_len support structures - we create a refcount object
-   extended with the user provided data pointer & destroy function */
+// grpc_slice_new_with_len support structures - we create a refcount object
+// extended with the user provided data pointer & destroy function
 class NewWithLenSliceRefcount : public grpc_slice_refcount {
  public:
   NewWithLenSliceRefcount(void (*destroy)(void*, size_t), void* user_data,
@@ -128,7 +128,7 @@ class NewWithLenSliceRefcount : public grpc_slice_refcount {
   void (*user_destroy_)(void*, size_t);
 };
 
-/** grpc_slice_from_moved_(string|buffer) ref count .*/
+/// grpc_slice_from_moved_(string|buffer) ref count .
 class MovedStringSliceRefCount : public grpc_slice_refcount {
  public:
   explicit MovedStringSliceRefCount(UniquePtr<char>&& str)
@@ -248,16 +248,16 @@ static grpc_slice sub_no_ref(const grpc_slice& source, size_t begin,
   GPR_ASSERT(end >= begin);
 
   if (source.refcount != nullptr) {
-    /* Enforce preconditions */
+    // Enforce preconditions
     GPR_ASSERT(source.data.refcounted.length >= end);
 
-    /* Build the result */
+    // Build the result
     subset.refcount = source.refcount;
-    /* Point into the source array */
+    // Point into the source array
     subset.data.refcounted.bytes = source.data.refcounted.bytes + begin;
     subset.data.refcounted.length = end - begin;
   } else {
-    /* Enforce preconditions */
+    // Enforce preconditions
     GPR_ASSERT(source.data.inlined.length >= end);
     subset.refcount = nullptr;
     subset.data.inlined.length = static_cast<uint8_t>(end - begin);
@@ -281,7 +281,7 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
            end - begin);
   } else {
     subset = grpc_slice_sub_no_ref(source, begin, end);
-    /* Bump the refcount */
+    // Bump the refcount
     if (subset.refcount != grpc_slice_refcount::NoopRefcount()) {
       subset.refcount->Ref();
     }
@@ -294,7 +294,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
   grpc_slice tail;
 
   if (source->refcount == nullptr) {
-    /* inlined data, copy it out */
+    // inlined data, copy it out
     GPR_ASSERT(source->data.inlined.length >= split);
     tail.refcount = nullptr;
     tail.data.inlined.length =
@@ -303,7 +303,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
            tail.data.inlined.length);
     source->data.inlined.length = static_cast<uint8_t>(split);
   } else if (source->refcount == grpc_slice_refcount::NoopRefcount()) {
-    /* refcount == NoopRefcount(), so we can just split in-place */
+    // refcount == NoopRefcount(), so we can just split in-place
     tail.refcount = grpc_slice_refcount::NoopRefcount();
     tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
     tail.data.refcounted.length = source->data.refcounted.length - split;
@@ -313,13 +313,13 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
     GPR_ASSERT(source->data.refcounted.length >= split);
     if (tail_length < sizeof(tail.data.inlined.bytes) &&
         ref_whom != GRPC_SLICE_REF_TAIL) {
-      /* Copy out the bytes - it'll be cheaper than refcounting */
+      // Copy out the bytes - it'll be cheaper than refcounting
       tail.refcount = nullptr;
       tail.data.inlined.length = static_cast<uint8_t>(tail_length);
       memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
              tail_length);
     } else {
-      /* Build the result */
+      // Build the result
       switch (ref_whom) {
         case GRPC_SLICE_REF_TAIL:
           tail.refcount = source->refcount;
@@ -330,13 +330,13 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
           break;
         case GRPC_SLICE_REF_BOTH:
           tail.refcount = source->refcount;
-          /* Bump the refcount */
+          // Bump the refcount
           if (tail.refcount != grpc_slice_refcount::NoopRefcount()) {
             tail.refcount->Ref();
           }
           break;
       }
-      /* Point into the source array */
+      // Point into the source array
       tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
       tail.data.refcounted.length = tail_length;
     }
@@ -374,13 +374,13 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   } else {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
-    /* Build the result */
+    // Build the result
     head.refcount = source->refcount;
-    /* Bump the refcount */
+    // Bump the refcount
     if (head.refcount != grpc_slice_refcount::NoopRefcount()) {
       head.refcount->Ref();
     }
-    /* Point into the source array */
+    // Point into the source array
     head.data.refcounted.bytes = source->data.refcounted.bytes;
     head.data.refcounted.length = split;
     source->data.refcounted.bytes += split;

data/src/core/lib/slice/slice.h

@@ -25,6 +25,8 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/internal/slice_cast.h>
+#include <grpc/event_engine/slice.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
@@ -194,6 +196,10 @@ struct CopyConstructors {
   static Out FromCopiedBuffer(const char* p, size_t len) {
     return Out(grpc_slice_from_copied_buffer(p, len));
   }
+  static Out FromCopiedBuffer(const uint8_t* p, size_t len) {
+    return Out(
+        grpc_slice_from_copied_buffer(reinterpret_cast<const char*>(p), len));
+  }
 
   template <typename Buffer>
   static Out FromCopiedBuffer(const Buffer& buffer) {
@@ -253,8 +259,9 @@ class StaticSlice : public slice_detail::BaseSlice,
   }
 };
 
-class MutableSlice : public slice_detail::BaseSlice,
-                     public slice_detail::CopyConstructors<MutableSlice> {
+class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND MutableSlice
+    : public slice_detail::BaseSlice,
+      public slice_detail::CopyConstructors<MutableSlice> {
  public:
   MutableSlice() = default;
   explicit MutableSlice(const grpc_slice& slice)
@@ -291,9 +298,10 @@ class MutableSlice : public slice_detail::BaseSlice,
   uint8_t& operator[](size_t i) { return mutable_data()[i]; }
 };
 
-class Slice : public slice_detail::BaseSlice,
-              public slice_detail::CopyConstructors<Slice>,
-              public slice_detail::StaticConstructors<Slice> {
+class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
+    : public slice_detail::BaseSlice,
+      public slice_detail::CopyConstructors<Slice>,
+      public slice_detail::StaticConstructors<Slice> {
  public:
   Slice() = default;
   ~Slice() { CSliceUnref(c_slice()); }
@@ -399,4 +407,29 @@ class Slice : public slice_detail::BaseSlice,
 
 }  // namespace grpc_core
 
+namespace grpc_event_engine {
+namespace experimental {
+namespace internal {
+template <>
+struct SliceCastable<grpc_core::Slice, grpc_slice> {};
+template <>
+struct SliceCastable<grpc_slice, grpc_core::Slice> {};
+template <>
+struct SliceCastable<grpc_core::Slice, Slice> {};
+template <>
+struct SliceCastable<Slice, grpc_core::Slice> {};
+
+template <>
+struct SliceCastable<grpc_core::MutableSlice, grpc_slice> {};
+template <>
+struct SliceCastable<grpc_slice, grpc_core::MutableSlice> {};
+
+template <>
+struct SliceCastable<grpc_core::MutableSlice, grpc_core::Slice> {};
+template <>
+struct SliceCastable<grpc_core::Slice, grpc_core::MutableSlice> {};
+}  // namespace internal
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
 #endif  // GRPC_CORE_LIB_SLICE_SLICE_H

data/src/core/lib/slice/slice_buffer.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>
 
@@ -22,7 +22,6 @@
 
 #include <string.h>
 
-#include <cstdint>
 #include <utility>
 
 #include <grpc/slice.h>
@@ -38,6 +37,12 @@ void SliceBuffer::Append(Slice slice) {
   grpc_slice_buffer_add(&slice_buffer_, slice.TakeCSlice());
 }
 
+void SliceBuffer::Append(const SliceBuffer& other) {
+  for (size_t i = 0; i < other.Count(); i++) {
+    Append(other.RefSlice(i));
+  }
+}
+
 size_t SliceBuffer::AppendIndexed(Slice slice) {
   return grpc_slice_buffer_add_indexed(&slice_buffer_, slice.TakeCSlice());
 }
@@ -67,22 +72,22 @@ std::string SliceBuffer::JoinIntoString() const {
 
 }  // namespace grpc_core
 
-/* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
+// grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1
 #define GROW(x) (3 * (x) / 2)
 
-/* Typically, we do not actually need to embiggen (by calling
- * memmove/malloc/realloc) - only if we were up against the full capacity of the
- * slice buffer. If do_embiggen is inlined, the compiler clobbers multiple
- * registers pointlessly in the common case. */
+// Typically, we do not actually need to embiggen (by calling
+// memmove/malloc/realloc) - only if we were up against the full capacity of the
+// slice buffer. If do_embiggen is inlined, the compiler clobbers multiple
+// registers pointlessly in the common case.
 static void GPR_ATTRIBUTE_NOINLINE do_embiggen(grpc_slice_buffer* sb,
                                                const size_t slice_count,
                                                const size_t slice_offset) {
   if (slice_offset != 0) {
-    /* Make room by moving elements if there's still space unused */
+    // Make room by moving elements if there's still space unused
     memmove(sb->base_slices, sb->slices, sb->count * sizeof(grpc_slice));
     sb->slices = sb->base_slices;
   } else {
-    /* Allocate more memory if no more space is available */
+    // Allocate more memory if no more space is available
     const size_t new_capacity = GROW(sb->capacity);
     sb->capacity = new_capacity;
     if (sb->base_slices == sb->inlined) {
@@ -104,7 +109,7 @@ static void maybe_embiggen(grpc_slice_buffer* sb) {
     return;
   }
 
-  /* How far away from sb->base_slices is sb->slices pointer */
+  // How far away from sb->base_slices is sb->slices pointer
   size_t slice_offset = static_cast<size_t>(sb->slices - sb->base_slices);
   size_t slice_count = sb->count + slice_offset;
   if (GPR_UNLIKELY(slice_count == sb->capacity)) {
@@ -186,11 +191,11 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
   }
 
   if (!s.refcount && n) {
-    /* if both the last slice in the slice buffer and the slice being added
-     are inlined (that is, that they carry their data inside the slice data
-     structure), and the back slice is not full, then concatenate directly
-     into the back slice, preventing many small slices being passed into
-     writes */
+    // if both the last slice in the slice buffer and the slice being added
+    // are inlined (that is, that they carry their data inside the slice data
+    // structure), and the back slice is not full, then concatenate directly
+    // into the back slice, preventing many small slices being passed into
+    // writes
     if (!back->refcount &&
         back->data.inlined.length < GRPC_SLICE_INLINED_SIZE) {
       if (s.data.inlined.length + back->data.inlined.length <=
@@ -214,7 +219,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
                s.data.inlined.length - cp1);
       }
       sb->length += s.data.inlined.length;
-      return; /* early out */
+      return;  // early out
     }
   }
   grpc_slice_buffer_add_indexed(sb, s);
@@ -254,34 +259,34 @@ void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
 
   if (a->base_slices == a->inlined) {
     if (b->base_slices == b->inlined) {
-      /* swap contents of inlined buffer */
+      // swap contents of inlined buffer
       grpc_slice temp[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
       memcpy(temp, a->base_slices, a_count * sizeof(grpc_slice));
       memcpy(a->base_slices, b->base_slices, b_count * sizeof(grpc_slice));
       memcpy(b->base_slices, temp, a_count * sizeof(grpc_slice));
     } else {
-      /* a is inlined, b is not - copy a inlined into b, fix pointers */
+      // a is inlined, b is not - copy a inlined into b, fix pointers
       a->base_slices = b->base_slices;
       b->base_slices = b->inlined;
       memcpy(b->base_slices, a->inlined, a_count * sizeof(grpc_slice));
     }
   } else if (b->base_slices == b->inlined) {
-    /* b is inlined, a is not - copy b inlined int a, fix pointers */
+    // b is inlined, a is not - copy b inlined int a, fix pointers
     b->base_slices = a->base_slices;
     a->base_slices = a->inlined;
     memcpy(a->base_slices, b->inlined, b_count * sizeof(grpc_slice));
   } else {
-    /* no inlining: easy swap */
+    // no inlining: easy swap
     std::swap(a->base_slices, b->base_slices);
   }
 
-  /* Update the slices pointers (cannot do a std::swap on slices fields here).
-   * Also note that since the base_slices pointers are already swapped we need
-   * use 'b_offset' for 'a->base_slices' and vice versa */
+  // Update the slices pointers (cannot do a std::swap on slices fields here).
+  // Also note that since the base_slices pointers are already swapped we need
+  // use 'b_offset' for 'a->base_slices' and vice versa
   a->slices = a->base_slices + b_offset;
   b->slices = b->base_slices + a_offset;
 
-  /* base_slices and slices fields are correctly set. Swap all other fields */
+  // base_slices and slices fields are correctly set. Swap all other fields
   std::swap(a->count, b->count);
   std::swap(a->capacity, b->capacity);
   std::swap(a->length, b->length);
@@ -289,16 +294,16 @@ void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
 
 void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
                                  grpc_slice_buffer* dst) {
-  /* anything to move? */
+  // anything to move?
   if (src->count == 0) {
     return;
   }
-  /* anything in dst? */
+  // anything in dst?
   if (dst->count == 0) {
     grpc_slice_buffer_swap(src, dst);
     return;
   }
-  /* both buffers have data - copy, and reset src */
+  // both buffers have data - copy, and reset src
   grpc_slice_buffer_addn(dst, src->slices, src->count);
   src->count = 0;
   src->length = 0;
@@ -325,13 +330,13 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
     } else if (n == slice_len) {
       grpc_slice_buffer_add(dst, slice);
       break;
-    } else if (incref) { /* n < slice_len */
+    } else if (incref) {  // n < slice_len
       grpc_slice_buffer_undo_take_first(
           src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_BOTH));
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);
       grpc_slice_buffer_add(dst, slice);
       break;
-    } else { /* n < slice_len */
+    } else {  // n < slice_len
       grpc_slice_buffer_undo_take_first(
           src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_TAIL));
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);