grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

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

@@ -19,13 +19,20 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
+#include "absl/container/inlined_vector.h"
+#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"

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

@@ -18,8 +18,16 @@
 
 #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>
 
+// IWYU pragma: no_include <ext/alloc_traits.h>
+
 namespace grpc_core {
 
 ServiceConfigParser ServiceConfigParser::Builder::Build() {

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,44 @@
 
 #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) {
+  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+}
+
+}  // namespace grpc_core
 
 /* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
 #define GROW(x) (3 * (x) / 2)
@@ -91,15 +120,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 +158,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 +235,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);

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

@@ -0,0 +1,106 @@
+// 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 <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_move_into(&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=(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_move_into(&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() { 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);
+
+  /// The total number of bytes held by the SliceBuffer
+  size_t Length() { return slice_buffer_.length; }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  grpc_slice_buffer* RawSliceBuffer() { return &slice_buffer_; }
+
+ private:
+  /// The backing raw slice buffer.
+  grpc_slice_buffer slice_buffer_;
+};
+
+}  // namespace grpc_core
+
+#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_split.cc

@@ -16,8 +16,11 @@
 
 #include "src/core/lib/slice/slice_split.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
 /** Finds the initial (\a begin) and final (\a end) offsets of the next

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

@@ -21,11 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-#include <stddef.h>
-
 #include <grpc/slice.h>
-#include <grpc/slice_buffer.h>
 
 /** Split \a str by the separator \a sep. Results are stored in \a dst, which
  * should be a properly initialized instance. */

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

@@ -20,6 +20,10 @@
 
 #include "src/core/lib/slice/slice_string_helpers.h"
 
+#include <stddef.h>
+
+#include <utility>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/slice/slice_internal.h"

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

@@ -21,13 +21,10 @@
 
 #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. */

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) {

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

@@ -18,17 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <string.h>
 
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
-#include <grpc/grpc.h>
-#include <grpc/slice_buffer.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.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"
 
 int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
                                  grpc_byte_buffer* buffer) {