grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

data/src/core/lib/service_config/service_config_impl.h

@@ -19,13 +19,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/string_util.h>
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
@@ -115,8 +121,7 @@ class ServiceConfigImpl final : public ServiceConfig {
       nullptr;
   // Storage for all the vectors that are being used in
   // parsed_method_configs_table_.
-  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>,
-                      32>
+  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>>
       parsed_method_config_vectors_storage_;
 };
 

data/src/core/lib/service_config/service_config_parser.cc

@@ -18,6 +18,12 @@
 
 #include "src/core/lib/service_config/service_config_parser.h"
 
+#include <stdlib.h>
+
+#include <string>
+
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/log.h>
 
 namespace grpc_core {
@@ -51,7 +57,7 @@ ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
     grpc_error_handle parser_error = GRPC_ERROR_NONE;
     auto parsed_config =
         registered_parsers_[i]->ParseGlobalParams(args, json, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parser_error)) {
       error_list.push_back(parser_error);
     }
     parsed_global_configs.push_back(std::move(parsed_config));
@@ -72,7 +78,7 @@ ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
     grpc_error_handle parser_error = GRPC_ERROR_NONE;
     auto parsed_config =
         registered_parsers_[i]->ParsePerMethodParams(args, json, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parser_error)) {
       error_list.push_back(parser_error);
     }
     parsed_method_configs.push_back(std::move(parsed_config));

data/src/core/lib/service_config/service_config_parser.h

@@ -19,10 +19,17 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <algorithm>
 #include <memory>
+#include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"

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

@@ -27,7 +27,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 /* --- Constants. --- */
 

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <grpc/slice.h>
 
 /* Encodes data using base64. It is the caller's responsibility to free

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

@@ -20,12 +20,15 @@
 
 #include "src/core/lib/slice/percent_encoding.h"
 
+#include <stdlib.h>
+
 #include <cstdint>
+#include <type_traits>
+#include <utility>
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/bitset.h"
-#include "src/core/lib/slice/slice_internal.h"
 
 #if __cplusplus > 201103l
 #define GRPC_PCTENCODE_CONSTEXPR_FN constexpr

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

@@ -28,12 +28,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
-#include "absl/types/optional.h"
-
-#include <grpc/slice.h>
-
 #include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {

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

@@ -22,12 +22,13 @@
 
 #include <string.h>
 
+#include <new>
+
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount_base.h"
 

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

@@ -17,11 +17,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <cstdint>
+#include <string>
+#include <utility>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -41,12 +46,12 @@
 //   MutableSlice - provides a guarantee of unique ownership, meaning the
 //                  underlying data can be mutated safely.
 
-namespace grpc_core {
+// This slice implementation is an extension of the event engine Slice
+// implementation defined in <grpc/event_engine/slice.h>. Changes to this
+// implementation might warrant changes to the public event engine Slice
+// type as well.
 
-// Forward declarations
-class Slice;
-class StaticSlice;
-class MutableSlice;
+namespace grpc_core {
 
 namespace slice_detail {
 

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

@@ -21,7 +21,7 @@
 #include <grpc/slice.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 /* Public API */
 grpc_slice grpc_slice_ref(grpc_slice slice) {

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

@@ -18,15 +18,55 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice_buffer.h"
+
 #include <string.h>
 
+#include <cstdint>
+#include <utility>
+
+#include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+
+namespace grpc_core {
+
+void SliceBuffer::Append(Slice slice) {
+  grpc_slice_buffer_add(&slice_buffer_, slice.TakeCSlice());
+}
+
+size_t SliceBuffer::AppendIndexed(Slice slice) {
+  return grpc_slice_buffer_add_indexed(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::TakeFirst() {
+  return Slice(grpc_slice_buffer_take_first(&slice_buffer_));
+}
+
+void SliceBuffer::Prepend(Slice slice) {
+  grpc_slice_buffer_undo_take_first(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::RefSlice(size_t index) const {
+  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+}
+
+std::string SliceBuffer::JoinIntoString() const {
+  std::string result;
+  result.reserve(slice_buffer_.length);
+  for (size_t i = 0; i < slice_buffer_.count; i++) {
+    result.append(reinterpret_cast<const char*>(
+                      GRPC_SLICE_START_PTR(slice_buffer_.slices[i])),
+                  GRPC_SLICE_LENGTH(slice_buffer_.slices[i]));
+  }
+  return result;
+}
+
+}  // namespace grpc_core
 
 /* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
 #define GROW(x) (3 * (x) / 2)
@@ -91,15 +131,6 @@ void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb) {
   }
 }
 
-void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_buffer_destroy_internal(sb);
-  } else {
-    grpc_slice_buffer_destroy_internal(sb);
-  }
-}
-
 uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
   grpc_slice* back;
   uint8_t* out;
@@ -138,13 +169,29 @@ size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice s) {
 
 void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
   size_t n = sb->count;
-  /* if both the last slice in the slice buffer and the slice being added
+  grpc_slice* back = nullptr;
+  if (n != 0) {
+    back = &sb->slices[n - 1];
+  }
+  if (s.refcount != nullptr && back != nullptr &&
+      s.refcount == back->refcount &&
+      GRPC_SLICE_START_PTR(s) == GRPC_SLICE_END_PTR(*back)) {
+    // Merge the two slices into one because they are contiguous and share the
+    // same refcount object.
+    back->data.refcounted.length += GRPC_SLICE_LENGTH(s);
+    sb->length += GRPC_SLICE_LENGTH(s);
+    // Unref the merged slice.
+    grpc_slice_unref_internal(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 (!s.refcount && n) {
-    grpc_slice* back = &sb->slices[n - 1];
     if (!back->refcount &&
         back->data.inlined.length < GRPC_SLICE_INLINED_SIZE) {
       if (s.data.inlined.length + back->data.inlined.length <=
@@ -199,15 +246,6 @@ void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb) {
   sb->slices = sb->base_slices;
 }
 
-void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_buffer_reset_and_unref_internal(sb);
-  } else {
-    grpc_slice_buffer_reset_and_unref_internal(sb);
-  }
-}
-
 void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
   size_t a_offset = static_cast<size_t>(a->slices - a->base_slices);
   size_t b_offset = static_cast<size_t>(b->slices - b->base_slices);
@@ -343,6 +381,24 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
   }
 }
 
+void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
+                                              void* dst) {
+  uint8_t* dstp = static_cast<uint8_t*>(dst);
+  GPR_ASSERT(src->length >= n);
+
+  for (size_t i = 0; i < src->count; i++) {
+    grpc_slice slice = src->slices[i];
+    size_t slice_len = GRPC_SLICE_LENGTH(slice);
+    if (slice_len >= n) {
+      memcpy(dstp, GRPC_SLICE_START_PTR(slice), n);
+      return;
+    }
+    memcpy(dstp, GRPC_SLICE_START_PTR(slice), slice_len);
+    dstp += slice_len;
+    n -= slice_len;
+  }
+}
+
 void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
                                 grpc_slice_buffer* garbage) {
   GPR_ASSERT(n <= sb->length);

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

@@ -0,0 +1,137 @@
+// Copyright 2022 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_BUFFER_Habc_SLICE_BUFFER_H
+#define GRPC_CORE_LIB_SLICE_SLICE_BUFFER_Habc_SLICE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+
+#include <string>
+
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+/// A slice buffer holds the memory for a collection of slices.
+/// The SliceBuffer object itself is meant to only hide the C-style API,
+/// and won't hold the data itself. In terms of lifespan, the
+/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
+/// like a transport or an endpoint.
+///
+/// This lifespan rule is likely to change in the future, as we may
+/// collapse the grpc_slice_buffer structure straight into this class.
+///
+/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
+/// and its documentation will move here once we remove the C structure,
+/// which should happen before the Event Engine's API is no longer
+/// an experimental API.
+class SliceBuffer {
+ public:
+  explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); }
+  SliceBuffer(const SliceBuffer& other) = delete;
+  SliceBuffer(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_init(&slice_buffer_);
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+  }
+  /// Upon destruction, the underlying raw slice buffer is cleaned out and all
+  /// slices are unreffed.
+  ~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); }
+
+  SliceBuffer& operator=(const SliceBuffer&) = delete;
+  SliceBuffer& operator=(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+    return *this;
+  }
+
+  /// 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);
+
+  /// Adds a new slice into the SliceBuffer at the next available index.
+  /// Returns the index at which the new slice is added.
+  size_t AppendIndexed(Slice slice);
+
+  /// Returns the number of slices held by the SliceBuffer.
+  size_t Count() const { return slice_buffer_.count; }
+
+  /// Removes/deletes the last n bytes in the SliceBuffer.
+  void RemoveLastNBytes(size_t n) {
+    grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
+  void MoveFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
+  /// Removes and unrefs all slices in the SliceBuffer.
+  void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
+
+  /// Removes the first slice in the SliceBuffer and returns it.
+  Slice TakeFirst();
+
+  /// Prepends the slice to the the front of the SliceBuffer.
+  void Prepend(Slice slice);
+
+  /// Increased the ref-count of slice at the specified index and returns the
+  /// associated slice.
+  Slice RefSlice(size_t index) const;
+
+  /// The total number of bytes held by the SliceBuffer
+  size_t Length() const { return slice_buffer_.length; }
+
+  /// Swap with another slice buffer
+  void Swap(SliceBuffer* other) {
+    grpc_slice_buffer_swap(c_slice_buffer(), other->c_slice_buffer());
+  }
+
+  /// Concatenate all slices and return the resulting string.
+  std::string JoinIntoString() const;
+
+  // Return a copy of the slice buffer
+  SliceBuffer Copy() const {
+    SliceBuffer copy;
+    for (size_t i = 0; i < Count(); i++) {
+      copy.Append(RefSlice(i));
+    }
+    return copy;
+  }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  const grpc_slice_buffer* c_slice_buffer() const { return &slice_buffer_; }
+
+  const grpc_slice& c_slice_at(size_t index) {
+    return slice_buffer_.slices[index];
+  }
+
+ private:
+  /// The backing raw slice buffer.
+  grpc_slice_buffer slice_buffer_;
+};
+
+}  // namespace grpc_core
+
+// Copy the first n bytes of src into memory pointed to by dst.
+void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
+                                              void* dst);
+
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_BUFFER_H

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

@@ -0,0 +1,35 @@
+/*
+ *
+ * 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>
+
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/slice/slice_internal.h"
+
+void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
+  grpc_core::ExecCtx exec_ctx;
+  grpc_slice_buffer_destroy_internal(sb);
+}
+
+void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
+  grpc_core::ExecCtx exec_ctx;
+  grpc_slice_buffer_reset_and_unref_internal(sb);
+}

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

@@ -21,17 +21,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <stdint.h>
+
+#include <cstddef>
+#include <string>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/slice_buffer.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/gprpp/ref_counted.h"
 #include "src/core/lib/slice/slice_refcount.h"
 
 void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb);

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

@@ -17,11 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <stdint.h>
 
-#include <grpc/support/alloc.h>
+#include <grpc/slice.h>
 
-#include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/slice/slice_refcount_base.h"
 
 namespace grpc_core {

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

@@ -17,10 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
+#include <stddef.h>
 
-#include <grpc/slice.h>
-#include <grpc/support/log.h>
+#include <atomic>
 
 // grpc_slice_refcount : A reference count for grpc_slice.
 struct grpc_slice_refcount {

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

@@ -21,24 +21,8 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/slice/slice_internal.h"
 
 char* grpc_dump_slice(const grpc_slice& s, uint32_t flags) {
   return gpr_dump(reinterpret_cast<const char*> GRPC_SLICE_START_PTR(s),
                   GRPC_SLICE_LENGTH(s), flags);
 }
-
-grpc_slice grpc_dump_slice_to_slice(const grpc_slice& s, uint32_t flags) {
-  size_t len;
-  grpc_core::UniquePtr<char> ptr(
-      gpr_dump_return_len(reinterpret_cast<const char*> GRPC_SLICE_START_PTR(s),
-                          GRPC_SLICE_LENGTH(s), flags, &len));
-  return grpc_slice_from_moved_buffer(std::move(ptr), len);
-}
-
-bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result) {
-  return gpr_parse_bytes_to_uint32(
-             reinterpret_cast<const char*> GRPC_SLICE_START_PTR(str),
-             GRPC_SLICE_LENGTH(str), result) != 0;
-}

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

@@ -21,18 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-#include <stddef.h>
+#include <stdint.h>
 
 #include <grpc/slice.h>
 
-#include "src/core/lib/gpr/string.h"
-
 /* Calls gpr_dump on a slice. */
 char* grpc_dump_slice(const grpc_slice& slice, uint32_t flags);
-/* Calls gpr_dump on a slice and returns the result as a slice. */
-grpc_slice grpc_dump_slice_to_slice(const grpc_slice& slice, uint32_t flags);
-
-bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result);
 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_STRING_HELPERS_H */

data/src/core/lib/surface/builtins.cc

@@ -16,8 +16,13 @@
 
 #include "src/core/lib/surface/builtins.h"
 
+#include <limits.h>
+
+#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/lib/surface/server.h"
 
@@ -36,12 +41,12 @@ void RegisterBuiltins(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_LAME_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
       [](ChannelStackBuilder* builder) {
-        builder->AppendFilter(&grpc_lame_filter, nullptr);
+        builder->AppendFilter(&LameClientFilter::kFilter);
         return true;
       });
   builder->channel_init()->RegisterStage(
       GRPC_SERVER_CHANNEL, INT_MAX, [](ChannelStackBuilder* builder) {
-        builder->PrependFilter(&Server::kServerTopFilter, nullptr);
+        builder->PrependFilter(&Server::kServerTopFilter);
         return true;
       });
 }

data/src/core/lib/surface/byte_buffer.cc

@@ -18,12 +18,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <grpc/byte_buffer.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices,
                                               size_t nslices) {