grpc 1.47.0-x86_64-linux → 1.48.0.pre1-x86_64-linux

data/src/core/lib/security/transport/security_handshaker.cc

@@ -20,11 +20,24 @@
 
 #include "src/core/lib/security/transport/security_handshaker.h"
 
-#include <stdbool.h>
+#include <limits.h>
+#include <stdint.h>
 #include <string.h>
 
 #include <limits>
-
+#include <memory>
+#include <string>
+
+#include "absl/base/attributes.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc_security.h>
+#include <grpc/grpc_security_constants.h>
+#include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -32,12 +45,24 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/transport/secure_endpoint.h"
 #include "src/core/lib/security/transport/tsi_error.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_factory.h"
+#include "src/core/lib/transport/handshaker_registry.h"
 #include "src/core/tsi/transport_security_grpc.h"
 
 #define GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE 256
@@ -173,7 +198,7 @@ void SecurityHandshaker::CleanupArgsForFailureLocked() {
 // If the handshake failed or we're shutting down, clean up and invoke the
 // callback with the error.
 void SecurityHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     // If we were shut down after the handshake succeeded but before an
     // endpoint callback was invoked, we need to generate our own error.
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshaker shutdown");
@@ -225,7 +250,7 @@ MakeChannelzSecurityFromAuthContext(grpc_auth_context* auth_context) {
 
 void SecurityHandshaker::OnPeerCheckedInner(grpc_error_handle error) {
   MutexLock lock(&mu_);
-  if (error != GRPC_ERROR_NONE || is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || is_shutdown_) {
     HandshakeFailedLocked(error);
     return;
   }
@@ -373,8 +398,16 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
     return error;
   }
   if (result != TSI_OK) {
+    auto* security_connector =
+        grpc_security_connector_find_in_args(args_->args);
+    absl::string_view connector_type = "<unknown>";
+    if (security_connector != nullptr) {
+      connector_type = security_connector->type().name();
+    }
     return grpc_set_tsi_error_result(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake failed"), result);
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(
+            absl::StrCat(connector_type, " handshake failed")),
+        result);
   }
   // Update handshaker result.
   if (handshaker_result != nullptr) {
@@ -418,7 +451,7 @@ void SecurityHandshaker::OnHandshakeNextDoneGrpcWrapper(
   MutexLock lock(&h->mu_);
   grpc_error_handle error = h->OnHandshakeNextDoneLocked(
       result, bytes_to_send, bytes_to_send_size, handshaker_result);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     h->HandshakeFailedLocked(error);
   } else {
     h.release();  // Avoid unref
@@ -462,7 +495,7 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<SecurityHandshaker> h(static_cast<SecurityHandshaker*>(arg));
   MutexLock lock(&h->mu_);
-  if (error != GRPC_ERROR_NONE || h->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || h->is_shutdown_) {
     h->HandshakeFailedLocked(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Handshake read failed", &error, 1));
     return;
@@ -471,7 +504,7 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn(
   size_t bytes_received_size = h->MoveReadBufferIntoHandshakeBuffer();
   // Call TSI handshaker.
   error = h->DoHandshakerNextLocked(h->handshake_buffer_, bytes_received_size);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     h->HandshakeFailedLocked(error);
   } else {
     h.release();  // Avoid unref
@@ -495,7 +528,7 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFn(void* arg,
                                                      grpc_error_handle error) {
   RefCountedPtr<SecurityHandshaker> h(static_cast<SecurityHandshaker*>(arg));
   MutexLock lock(&h->mu_);
-  if (error != GRPC_ERROR_NONE || h->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || h->is_shutdown_) {
     h->HandshakeFailedLocked(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Handshake write failed", &error, 1));
     return;
@@ -511,7 +544,7 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFn(void* arg,
         /*urgent=*/true, /*min_progress_size=*/1);
   } else {
     error = h->CheckPeerLocked();
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       h->HandshakeFailedLocked(error);
       return;
     }
@@ -545,7 +578,7 @@ void SecurityHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   size_t bytes_received_size = MoveReadBufferIntoHandshakeBuffer();
   grpc_error_handle error =
       DoHandshakerNextLocked(handshake_buffer_, bytes_received_size);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     HandshakeFailedLocked(error);
   } else {
     ref.release();  // Avoid unref

data/src/core/lib/security/transport/security_handshaker.h

@@ -21,9 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/transport/handshaker.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -20,13 +20,35 @@
 
 #include <string.h>
 
+#include <algorithm>
+#include <new>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/transport/auth_filters.h"
+#include "src/core/lib/security/transport/auth_filters.h"  // IWYU pragma: keep
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 static void recv_initial_metadata_ready(void* arg, grpc_error_handle error);
 static void recv_trailing_metadata_ready(void* user_data,
@@ -149,7 +171,7 @@ static void on_md_processing_done_inner(grpc_call_element* elem,
             "response_md in auth metadata processing not supported for now. "
             "Ignoring...");
   }
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     for (size_t i = 0; i < num_consumed_md; i++) {
       batch->payload->recv_initial_metadata.recv_initial_metadata->Remove(
           grpc_core::StringViewFromSlice(consumed_md[i].key));
@@ -204,7 +226,7 @@ static void cancel_call(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   // If the result was not already processed, invoke the callback now.
-  if (error != GRPC_ERROR_NONE &&
+  if (!GRPC_ERROR_IS_NONE(error) &&
       gpr_atm_full_cas(&calld->state, static_cast<gpr_atm>(STATE_INIT),
                        static_cast<gpr_atm>(STATE_CANCELLED))) {
     on_md_processing_done_inner(elem, nullptr, 0, nullptr, 0,
@@ -218,7 +240,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_transport_stream_op_batch* batch = calld->recv_initial_metadata_batch;
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (chand->creds != nullptr &&
         chand->creds->auth_metadata_processor().process != nullptr) {
       // We're calling out to the application, so we need to make sure

data/src/core/lib/security/util/json_util.cc

@@ -20,11 +20,12 @@
 
 #include "src/core/lib/security/util/json_util.h"
 
-#include <string.h>
+#include <map>
+#include <string>
+#include <utility>
 
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/error.h"

data/src/core/lib/security/util/json_util.h

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 

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

@@ -28,6 +28,7 @@
 #include "absl/strings/string_view.h"
 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
@@ -39,7 +40,7 @@ namespace grpc_core {
 /// easily access method and global parameters for the call.
 class ServiceConfigCallData {
  public:
-  using CallAttributes = std::map<const char*, absl::string_view>;
+  using CallAttributes = std::map<UniqueTypeName, absl::string_view>;
 
   ServiceConfigCallData() : method_configs_(nullptr) {}
 

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

@@ -43,7 +43,7 @@ RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
     grpc_error_handle* error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
-  if (*error != GRPC_ERROR_NONE) return nullptr;
+  if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
   return MakeRefCounted<ServiceConfigImpl>(args, std::string(json_string),
                                            std::move(json), error);
 }
@@ -63,9 +63,9 @@ ServiceConfigImpl::ServiceConfigImpl(const grpc_channel_args* args,
   parsed_global_configs_ =
       CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
           args, json_, &global_error);
-  if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
+  if (!GRPC_ERROR_IS_NONE(global_error)) error_list.push_back(global_error);
   grpc_error_handle local_error = ParsePerMethodParams(args);
-  if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
+  if (!GRPC_ERROR_IS_NONE(local_error)) error_list.push_back(local_error);
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
                                            &error_list);
@@ -88,7 +88,7 @@ grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
   *parsed_configs =
       CoreConfiguration::Get().service_config_parser().ParsePerMethodParameters(
           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_config_vectors_storage_.push_back(std::move(parsed_configs));
@@ -106,7 +106,7 @@ grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
     for (const Json& name : name_array) {
       grpc_error_handle parse_error = GRPC_ERROR_NONE;
       std::string path = ParseJsonMethodName(name, &parse_error);
-      if (parse_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(parse_error)) {
         error_list.push_back(parse_error);
       } else {
         found_name = true;
@@ -156,7 +156,7 @@ grpc_error_handle ServiceConfigImpl::ParsePerMethodParams(
         continue;
       }
       grpc_error_handle error = ParseJsonMethodConfig(args, method_config);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         error_list.push_back(error);
       }
     }

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

@@ -26,7 +26,6 @@
 #include <unordered_map>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
@@ -122,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

@@ -26,8 +26,6 @@
 
 #include <grpc/support/log.h>
 
-// IWYU pragma: no_include <ext/alloc_traits.h>
-
 namespace grpc_core {
 
 ServiceConfigParser ServiceConfigParser::Builder::Build() {
@@ -59,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));
@@ -80,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/slice/slice_buffer.cc

@@ -51,10 +51,21 @@ void SliceBuffer::Prepend(Slice slice) {
   grpc_slice_buffer_undo_take_first(&slice_buffer_, slice.TakeCSlice());
 }
 
-Slice SliceBuffer::RefSlice(size_t index) {
+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 */
@@ -370,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

@@ -19,6 +19,8 @@
 
 #include <string.h>
 
+#include <string>
+
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 
@@ -45,14 +47,15 @@ class SliceBuffer {
   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_);
+    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_move_into(&slice_buffer_, &other.slice_buffer_);
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
     return *this;
   }
 
@@ -65,7 +68,7 @@ class SliceBuffer {
   size_t AppendIndexed(Slice slice);
 
   /// Returns the number of slices held by the SliceBuffer.
-  size_t Count() { return slice_buffer_.count; }
+  size_t Count() const { return slice_buffer_.count; }
 
   /// Removes/deletes the last n bytes in the SliceBuffer.
   void RemoveLastNBytes(size_t n) {
@@ -88,13 +91,37 @@ class SliceBuffer {
 
   /// Increased the ref-count of slice at the specified index and returns the
   /// associated slice.
-  Slice RefSlice(size_t index);
+  Slice RefSlice(size_t index) const;
 
   /// The total number of bytes held by the SliceBuffer
-  size_t Length() { return slice_buffer_.length; }
+  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* RawSliceBuffer() { return &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.
@@ -103,4 +130,8 @@ class SliceBuffer {
 
 }  // 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_string_helpers.cc

@@ -20,29 +20,9 @@
 
 #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"
 
 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

@@ -27,9 +27,5 @@
 
 /* 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 */