grpc 1.50.0.pre1 → 1.52.0.pre2

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>
@@ -31,7 +30,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 
@@ -39,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());
 }
@@ -52,7 +56,7 @@ void SliceBuffer::Prepend(Slice slice) {
 }
 
 Slice SliceBuffer::RefSlice(size_t index) const {
-  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+  return Slice(CSliceRef(slice_buffer_.slices[index]));
 }
 
 std::string SliceBuffer::JoinIntoString() const {
@@ -68,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) {
@@ -105,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)) {
@@ -120,12 +124,12 @@ void grpc_slice_buffer_init(grpc_slice_buffer* sb) {
   sb->base_slices = sb->slices = sb->inlined;
 }
 
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb) {
-  grpc_slice_buffer_reset_and_unref_internal(sb);
+void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
+  grpc_slice_buffer_reset_and_unref(sb);
   if (sb->base_slices != sb->inlined) {
     gpr_free(sb->base_slices);
     // As a precaution, set sb->base_slices to equal sb->inlined
-    // to prevent a double free attempt if grpc_slice_buffer_destroy_internal
+    // to prevent a double free attempt if grpc_slice_buffer_destroy
     // is invoked two times on the same slice buffer.
     sb->base_slices = sb->slices = sb->inlined;
   }
@@ -181,17 +185,17 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
     back->data.refcounted.length += GRPC_SLICE_LENGTH(s);
     sb->length += GRPC_SLICE_LENGTH(s);
     // Unref the merged slice.
-    grpc_slice_unref_internal(s);
+    grpc_core::CSliceUnref(s);
     // early out
     return;
   }
 
   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 <=
@@ -215,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);
@@ -235,10 +239,10 @@ void grpc_slice_buffer_pop(grpc_slice_buffer* sb) {
   }
 }
 
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb) {
+void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
   size_t i;
   for (i = 0; i < sb->count; i++) {
-    grpc_slice_unref_internal(sb->slices[i]);
+    grpc_core::CSliceUnref(sb->slices[i]);
   }
 
   sb->count = 0;
@@ -255,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);
@@ -290,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;
@@ -326,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);
@@ -370,13 +374,13 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
       n = 0;
     } else if (slice_len == n) {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), n);
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
       n = 0;
     } else {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), slice_len);
       dstp += slice_len;
       n -= slice_len;
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
     }
   }
 }
@@ -412,14 +416,14 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       return;
     } else if (slice_len == n) {
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       sb->count = idx;
       return;
@@ -427,7 +431,7 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       n -= slice_len;
       sb->count = idx;
@@ -449,7 +453,7 @@ grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb) {
 void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb) {
   GPR_DEBUG_ASSERT(sb->count > 0);
   sb->length -= GRPC_SLICE_LENGTH(sb->slices[0]);
-  grpc_slice_unref_internal(sb->slices[0]);
+  grpc_core::CSliceUnref(sb->slices[0]);
   sb->slices++;
   if (--sb->count == 0) {
     sb->slices = sb->base_slices;

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

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_SLICE_SLICE_BUFFER_Habc_SLICE_BUFFER_H
-#define GRPC_CORE_LIB_SLICE_SLICE_BUFFER_Habc_SLICE_BUFFER_H
+#ifndef GRPC_CORE_LIB_SLICE_SLICE_BUFFER_H
+#define GRPC_CORE_LIB_SLICE_SLICE_BUFFER_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <string.h>
 
 #include <string>
@@ -62,6 +63,9 @@ class SliceBuffer {
   /// Appends a new slice into the SliceBuffer and makes an attempt to merge
   /// this slice with the last slice in the SliceBuffer.
   void Append(Slice slice);
+  /// Appends a SliceBuffer into the SliceBuffer and makes an attempt to merge
+  /// this slice with the last slice in the SliceBuffer.
+  void Append(const SliceBuffer& other);
 
   /// Adds a new slice into the SliceBuffer at the next available index.
   /// Returns the index at which the new slice is added.
@@ -80,6 +84,17 @@ class SliceBuffer {
     grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
   }
 
+  /// Removes/deletes the last n bytes in the SliceBuffer and add it to the
+  /// other SliceBuffer
+  void MoveLastNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {
+    grpc_slice_buffer_trim_end(&slice_buffer_, n, &other.slice_buffer_);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into the other SliceBuffer
+  void MoveFirstNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {
+    grpc_slice_buffer_move_first(&slice_buffer_, n, &other.slice_buffer_);
+  }
+
   /// Removes and unrefs all slices in the SliceBuffer.
   void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
 
@@ -93,6 +108,11 @@ class SliceBuffer {
   /// associated slice.
   Slice RefSlice(size_t index) const;
 
+  const Slice& operator[](size_t index) const {
+    return grpc_event_engine::experimental::internal::SliceCast<Slice>(
+        slice_buffer_.slices[index]);
+  }
+
   /// The total number of bytes held by the SliceBuffer
   size_t Length() const { return slice_buffer_.length; }
 
@@ -113,6 +133,11 @@ class SliceBuffer {
     return copy;
   }
 
+  /// Add a small amount to the end of the slice buffer.
+  uint8_t* AddTiny(size_t n) {
+    return grpc_slice_buffer_tiny_add(&slice_buffer_, n);
+  }
+
   /// Return a pointer to the back raw grpc_slice_buffer
   grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
 

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

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H
 #define GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H
@@ -26,19 +26,13 @@
 #include <cstddef>
 #include <string>
 
+#include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/slice/slice_refcount.h"
-
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb);
-void grpc_slice_buffer_partial_unref_internal(grpc_slice_buffer* sb,
-                                              size_t idx);
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb);
 
 // Returns a pointer to the first slice in the slice buffer without giving
 // ownership to or a reference count on that slice.
@@ -54,7 +48,6 @@ void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb);
 void grpc_slice_buffer_sub_first(grpc_slice_buffer* sb, size_t begin,
                                  size_t end);
 
-void grpc_test_only_set_slice_hash_seed(uint32_t seed);
 // if slice matches a static slice, returns the static slice
 // otherwise returns the passed in slice (without reffing it)
 // used for surface boundaries where we might receive an un-interned static
@@ -64,11 +57,6 @@ grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
 uint32_t grpc_static_slice_hash(grpc_slice s);
 int grpc_static_slice_eq(grpc_slice a, grpc_slice b);
 
-inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {
-  return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                          grpc_core::g_hash_seed);
-}
-
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
                                         size_t len);
 grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p);
@@ -81,14 +69,6 @@ size_t grpc_slice_memory_usage(grpc_slice s);
 
 namespace grpc_core {
 
-struct SliceHash {
-  std::size_t operator()(const grpc_slice& slice) const {
-    return grpc_slice_hash_internal(slice);
-  }
-};
-
-extern uint32_t g_hash_seed;
-
 // Converts grpc_slice to absl::string_view.
 inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
   return absl::string_view(
@@ -98,8 +78,20 @@ inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
 
 }  // namespace grpc_core
 
+inline uint32_t grpc_slice_hash(const grpc_slice& s) {
+  return absl::HashOf(grpc_core::StringViewFromSlice(s));
+}
+
+namespace grpc_core {
+struct SliceHash {
+  std::size_t operator()(const grpc_slice& slice) const {
+    return grpc_slice_hash(slice);
+  }
+};
+}  // namespace grpc_core
+
 inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) {
   return grpc_slice_eq(s1, s2);
 }
 
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H

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

@@ -17,29 +17,44 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <stddef.h>
 
-#include <grpc/slice.h>
+#include <atomic>
 
-#include "src/core/lib/slice/slice_refcount_base.h"
+// grpc_slice_refcount : A reference count for grpc_slice.
+struct grpc_slice_refcount {
+ public:
+  typedef void (*DestroyerFn)(grpc_slice_refcount*);
 
-namespace grpc_core {
-
-extern uint32_t g_hash_seed;
-
-}  // namespace grpc_core
-
-inline const grpc_slice& grpc_slice_ref_internal(const grpc_slice& slice) {
-  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
-    slice.refcount->Ref();
+  static grpc_slice_refcount* NoopRefcount() {
+    return reinterpret_cast<grpc_slice_refcount*>(1);
   }
-  return slice;
-}
 
-inline void grpc_slice_unref_internal(const grpc_slice& slice) {
-  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
-    slice.refcount->Unref();
+  grpc_slice_refcount() = default;
+
+  // Regular constructor for grpc_slice_refcount.
+  //
+  // Parameters:
+  //  1. DestroyerFn destroyer_fn
+  //  Called when the refcount goes to 0, with 'this' as parameter.
+  explicit grpc_slice_refcount(DestroyerFn destroyer_fn)
+      : destroyer_fn_(destroyer_fn) {}
+
+  void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (ref_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
+      destroyer_fn_(this);
+    }
   }
-}
 
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_H */
+  // Is this the only instance?
+  // For this to be useful the caller needs to ensure that if this is the only
+  // instance, no other instance could be created during this call.
+  bool IsUnique() const { return ref_.load(std::memory_order_relaxed) == 1; }
+
+ private:
+  std::atomic<size_t> ref_{1};
+  DestroyerFn destroyer_fn_ = nullptr;
+};
+
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_REFCOUNT_H

data/src/core/lib/slice/slice_string_helpers.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>
 

data/src/core/lib/slice/slice_string_helpers.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_SLICE_STRING_HELPERS_H
 #define GRPC_CORE_LIB_SLICE_SLICE_STRING_HELPERS_H
@@ -25,7 +25,7 @@
 
 #include <grpc/slice.h>
 
-/* Calls gpr_dump on a slice. */
+// Calls gpr_dump on a slice.
 char* grpc_dump_slice(const grpc_slice& slice, uint32_t flags);
 
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_STRING_HELPERS_H */
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_STRING_HELPERS_H

data/src/core/lib/surface/api_trace.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>