grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -35,22 +35,21 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
                                           grpc_error_handle* error) {
   if (json.type() != grpc_core::Json::Type::OBJECT) {
     if (error != nullptr) {
-      *error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
+      *error = GRPC_ERROR_CREATE("JSON value is not an object");
     }
     return nullptr;
   }
   auto it = json.object_value().find(prop_name);
   if (it == json.object_value().end()) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      *error = GRPC_ERROR_CREATE(
           absl::StrCat("Property ", prop_name, " not found in JSON object."));
     }
     return nullptr;
   }
   if (it->second.type() != grpc_core::Json::Type::STRING) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+      *error = GRPC_ERROR_CREATE(absl::StrCat(
           "Property ", prop_name, " n JSON object is not a string."));
     }
     return nullptr;
@@ -61,7 +60,7 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
 bool grpc_copy_json_string_property(const grpc_core::Json& json,
                                     const char* prop_name,
                                     char** copied_value) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   const char* prop_value =
       grpc_json_get_string_property(json, prop_name, &error);
   GRPC_LOG_IF_ERROR("Could not copy JSON property", error);

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

@@ -58,7 +58,7 @@
 namespace grpc_core {
 
 // TODO(roth): Consider stripping this down further to the completely minimal
-// interface requied to be exposed as part of the resolver API.
+// interface required to be exposed as part of the resolver API.
 class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
   static absl::string_view ChannelArgName() {

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

@@ -20,198 +20,151 @@
 
 #include <string.h>
 
-#include <map>
 #include <string>
 #include <utility>
 
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-
-#include <grpc/support/log.h>
+#include "absl/types/optional.h"
 
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 
+namespace {
+
+struct MethodConfig {
+  struct Name {
+    absl::optional<std::string> service;
+    absl::optional<std::string> method;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader = JsonObjectLoader<Name>()
+                                      .OptionalField("service", &Name::service)
+                                      .OptionalField("method", &Name::method)
+                                      .Finish();
+      return loader;
+    }
+
+    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+      if (!service.has_value() && method.has_value()) {
+        errors->AddError("method name populated without service name");
+      }
+    }
+
+    std::string Path() const {
+      if (!service.has_value() || service->empty()) return "";
+      return absl::StrCat("/", *service, "/",
+                          method.has_value() ? *method : "");
+    }
+  };
+
+  std::vector<Name> names;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader = JsonObjectLoader<MethodConfig>()
+                                    .OptionalField("name", &MethodConfig::names)
+                                    .Finish();
+    return loader;
+  }
+};
+
+}  // namespace
+
 absl::StatusOr<RefCountedPtr<ServiceConfig>> ServiceConfigImpl::Create(
     const ChannelArgs& args, absl::string_view json_string) {
   auto json = Json::Parse(json_string);
   if (!json.ok()) return json.status();
-  absl::Status status;
-  auto service_config = MakeRefCounted<ServiceConfigImpl>(
-      args, std::string(json_string), std::move(*json), &status);
-  if (!status.ok()) return status;
+  ValidationErrors errors;
+  auto service_config = Create(args, *json, json_string, &errors);
+  if (!errors.ok()) return errors.status("errors validating service config");
   return service_config;
 }
 
-ServiceConfigImpl::ServiceConfigImpl(const ChannelArgs& args,
-                                     std::string json_string, Json json,
-                                     absl::Status* status)
-    : json_string_(std::move(json_string)), json_(std::move(json)) {
-  GPR_DEBUG_ASSERT(status != nullptr);
-  if (json_.type() != Json::Type::OBJECT) {
-    *status = absl::InvalidArgumentError("JSON value is not an object");
-    return;
-  }
-  std::vector<std::string> errors;
-  auto parsed_global_configs =
-      CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
-          args, json_);
-  if (!parsed_global_configs.ok()) {
-    errors.emplace_back(parsed_global_configs.status().message());
-  } else {
-    parsed_global_configs_ = std::move(*parsed_global_configs);
-  }
-  absl::Status local_status = ParsePerMethodParams(args);
-  if (!local_status.ok()) errors.emplace_back(local_status.message());
-  if (!errors.empty()) {
-    *status = absl::InvalidArgumentError(absl::StrCat(
-        "Service config parsing errors: [", absl::StrJoin(errors, "; "), "]"));
-  }
-}
-
-ServiceConfigImpl::~ServiceConfigImpl() {
-  for (auto& p : parsed_method_configs_map_) {
-    grpc_slice_unref_internal(p.first);
-  }
+RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
+    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
+  return Create(args, json, json.Dump(), errors);
 }
 
-absl::Status ServiceConfigImpl::ParseJsonMethodConfig(const ChannelArgs& args,
-                                                      const Json& json,
-                                                      size_t index) {
-  std::vector<std::string> errors;
-  const ServiceConfigParser::ParsedConfigVector* vector_ptr = nullptr;
-  // Parse method config with each registered parser.
-  auto parsed_configs_or =
-      CoreConfiguration::Get().service_config_parser().ParsePerMethodParameters(
-          args, json);
-  if (!parsed_configs_or.ok()) {
-    errors.emplace_back(parsed_configs_or.status().message());
-  } else {
-    auto parsed_configs =
-        absl::make_unique<ServiceConfigParser::ParsedConfigVector>(
-            std::move(*parsed_configs_or));
-    parsed_method_config_vectors_storage_.push_back(std::move(parsed_configs));
-    vector_ptr = parsed_method_config_vectors_storage_.back().get();
+RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
+    const ChannelArgs& args, const Json& json, absl::string_view json_string,
+    ValidationErrors* errors) {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return nullptr;
   }
-  // Add an entry for each path.
-  auto it = json.object_value().find("name");
-  if (it != json.object_value().end()) {
-    if (it->second.type() != Json::Type::ARRAY) {
-      errors.emplace_back("field:name error:not of type Array");
-    } else {
-      const Json::Array& name_array = it->second.array_value();
-      for (const Json& name : name_array) {
-        absl::StatusOr<std::string> path = ParseJsonMethodName(name);
-        if (!path.ok()) {
-          errors.emplace_back(path.status().message());
+  auto service_config = MakeRefCounted<ServiceConfigImpl>();
+  service_config->json_string_ = std::string(json_string);
+  // Parse global parameters.
+  service_config->parsed_global_configs_ =
+      CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
+          args, json, errors);
+  // Parse per-method parameters.
+  auto method_configs = LoadJsonObjectField<std::vector<Json::Object>>(
+      json.object_value(), JsonArgs(), "methodConfig", errors,
+      /*required=*/false);
+  if (method_configs.has_value()) {
+    service_config->parsed_method_config_vectors_storage_.reserve(
+        method_configs->size());
+    for (size_t i = 0; i < method_configs->size(); ++i) {
+      const Json::Object& method_config_json = (*method_configs)[i];
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".methodConfig[", i, "]"));
+      // Have each parser read this method config.
+      auto parsed_configs =
+          CoreConfiguration::Get()
+              .service_config_parser()
+              .ParsePerMethodParameters(args, method_config_json, errors);
+      // Store the parsed configs.
+      service_config->parsed_method_config_vectors_storage_.push_back(
+          std::move(parsed_configs));
+      const ServiceConfigParser::ParsedConfigVector* vector_ptr =
+          &service_config->parsed_method_config_vectors_storage_.back();
+      // Parse the names.
+      auto method_config =
+          LoadFromJson<MethodConfig>(method_config_json, JsonArgs(), errors);
+      for (size_t j = 0; j < method_config.names.size(); ++j) {
+        ValidationErrors::ScopedField field(errors,
+                                            absl::StrCat(".name[", j, "]"));
+        std::string path = method_config.names[j].Path();
+        if (path.empty()) {
+          if (service_config->default_method_config_vector_ != nullptr) {
+            errors->AddError("duplicate default method config");
+          }
+          service_config->default_method_config_vector_ = vector_ptr;
         } else {
-          if (path->empty()) {
-            if (default_method_config_vector_ != nullptr) {
-              errors.emplace_back(
-                  "field:name error:multiple default method configs");
-            }
-            default_method_config_vector_ = vector_ptr;
+          grpc_slice key = grpc_slice_from_cpp_string(std::move(path));
+          // If the key is not already present in the map, this will
+          // store a ref to the key in the map.
+          auto& value = service_config->parsed_method_configs_map_[key];
+          if (value != nullptr) {
+            errors->AddError(absl::StrCat("multiple method configs for path ",
+                                          StringViewFromSlice(key)));
+            // The map entry already existed, so we need to unref the
+            // key we just created.
+            CSliceUnref(key);
           } else {
-            grpc_slice key = grpc_slice_from_cpp_string(std::move(*path));
-            // If the key is not already present in the map, this will
-            // store a ref to the key in the map.
-            auto& value = parsed_method_configs_map_[key];
-            if (value != nullptr) {
-              errors.emplace_back(
-                  "field:name error:multiple method configs with same name");
-              // The map entry already existed, so we need to unref the
-              // key we just created.
-              grpc_slice_unref_internal(key);
-            } else {
-              value = vector_ptr;
-            }
+            value = vector_ptr;
           }
         }
       }
     }
   }
-  if (!errors.empty()) {
-    return absl::InvalidArgumentError(
-        absl::StrCat("index ", index, ": [", absl::StrJoin(errors, "; "), "]"));
-  }
-  return absl::OkStatus();
-}
-
-absl::Status ServiceConfigImpl::ParsePerMethodParams(const ChannelArgs& args) {
-  auto it = json_.object_value().find("methodConfig");
-  if (it == json_.object_value().end()) return absl::OkStatus();
-  if (it->second.type() != Json::Type::ARRAY) {
-    return absl::InvalidArgumentError("field must be of type array");
-  }
-  std::vector<std::string> errors;
-  for (size_t i = 0; i < it->second.array_value().size(); ++i) {
-    const Json& method_config = it->second.array_value()[i];
-    if (method_config.type() != Json::Type::OBJECT) {
-      errors.emplace_back(absl::StrCat("index ", i, ": not of type Object"));
-    } else {
-      absl::Status status = ParseJsonMethodConfig(args, method_config, i);
-      if (!status.ok()) errors.emplace_back(status.message());
-    }
-  }
-  if (!errors.empty()) {
-    return absl::InvalidArgumentError(absl::StrCat(
-        "errors parsing methodConfig: [", absl::StrJoin(errors, "; "), "]"));
-  }
-  return absl::OkStatus();
+  return service_config;
 }
 
-absl::StatusOr<std::string> ServiceConfigImpl::ParseJsonMethodName(
-    const Json& json) {
-  if (json.type() != Json::Type::OBJECT) {
-    return absl::InvalidArgumentError("field:name error:type is not object");
-  }
-  // Find service name.
-  const std::string* service_name = nullptr;
-  auto it = json.object_value().find("service");
-  if (it != json.object_value().end() &&
-      it->second.type() != Json::Type::JSON_NULL) {
-    if (it->second.type() != Json::Type::STRING) {
-      return absl::InvalidArgumentError(
-          "field:name error: field:service error:not of type string");
-    }
-    if (!it->second.string_value().empty()) {
-      service_name = &it->second.string_value();
-    }
-  }
-  const std::string* method_name = nullptr;
-  // Find method name.
-  it = json.object_value().find("method");
-  if (it != json.object_value().end() &&
-      it->second.type() != Json::Type::JSON_NULL) {
-    if (it->second.type() != Json::Type::STRING) {
-      return absl::InvalidArgumentError(
-          "field:name error: field:method error:not of type string");
-    }
-    if (!it->second.string_value().empty()) {
-      method_name = &it->second.string_value();
-    }
-  }
-  // If neither service nor method are specified, it's the default.
-  // Method name may not be specified without service name.
-  if (service_name == nullptr) {
-    if (method_name != nullptr) {
-      return absl::InvalidArgumentError(
-          "field:name error:method name populated without service name");
-    }
-    return "";
+ServiceConfigImpl::~ServiceConfigImpl() {
+  for (auto& p : parsed_method_configs_map_) {
+    CSliceUnref(p.first);
   }
-  // Construct path.
-  return absl::StrCat("/", *service_name, "/",
-                      method_name == nullptr ? "" : *method_name);
 }
 
 const ServiceConfigParser::ParsedConfigVector*

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

@@ -26,7 +26,6 @@
 #include <unordered_map>
 #include <vector>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
@@ -35,6 +34,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
@@ -72,8 +72,15 @@ class ServiceConfigImpl final : public ServiceConfig {
   static absl::StatusOr<RefCountedPtr<ServiceConfig>> Create(
       const ChannelArgs& args, absl::string_view json_string);
 
-  ServiceConfigImpl(const ChannelArgs& args, std::string json_string, Json json,
-                    absl::Status* status);
+  // Alternate forms that are useful in edge cases.
+  static RefCountedPtr<ServiceConfig> Create(const ChannelArgs& args,
+                                             const Json& json,
+                                             absl::string_view json_string,
+                                             ValidationErrors* errors);
+  static RefCountedPtr<ServiceConfig> Create(const ChannelArgs& args,
+                                             const Json& json,
+                                             ValidationErrors* errors);
+
   ~ServiceConfigImpl() override;
 
   absl::string_view json_string() const override { return json_string_; }
@@ -94,20 +101,10 @@ class ServiceConfigImpl final : public ServiceConfig {
       const grpc_slice& path) const override;
 
  private:
-  // Helper functions for parsing the method configs.
-  absl::Status ParsePerMethodParams(const ChannelArgs& args);
-  absl::Status ParseJsonMethodConfig(const ChannelArgs& args, const Json& json,
-                                     size_t index);
-
-  // Returns a path string for the JSON name object specified by json.
-  // Sets *error on error.
-  static absl::StatusOr<std::string> ParseJsonMethodName(const Json& json);
-
   std::string json_string_;
   Json json_;
 
-  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-      parsed_global_configs_;
+  ServiceConfigParser::ParsedConfigVector parsed_global_configs_;
   // A map from the method name to the parsed config vector. Note that we are
   // using a raw pointer and not a unique pointer so that we can use the same
   // vector for multiple names.
@@ -118,11 +115,11 @@ class ServiceConfigImpl final : public ServiceConfig {
   const ServiceConfigParser::ParsedConfigVector* default_method_config_vector_ =
       nullptr;
   // Storage for all the vectors that are being used in
-  // parsed_method_configs_table_.
-  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>>
+  // parsed_method_configs_map_ and default_method_config_vector_.
+  std::vector<ServiceConfigParser::ParsedConfigVector>
       parsed_method_config_vectors_storage_;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H */
+#endif  // GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H

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

@@ -22,9 +22,7 @@
 
 #include <string>
 
-#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
@@ -49,43 +47,28 @@ void ServiceConfigParser::Builder::RegisterParser(
   registered_parsers_.emplace_back(std::move(parser));
 }
 
-absl::StatusOr<ServiceConfigParser::ParsedConfigVector>
+ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParseGlobalParameters(const ChannelArgs& args,
-                                           const Json& json) const {
+                                           const Json& json,
+                                           ValidationErrors* errors) const {
   ParsedConfigVector parsed_global_configs;
-  std::vector<std::string> errors;
-  for (size_t i = 0; i < registered_parsers_.size(); i++) {
-    auto parsed_config = registered_parsers_[i]->ParseGlobalParams(args, json);
-    if (!parsed_config.ok()) {
-      errors.emplace_back(parsed_config.status().message());
-    } else {
-      parsed_global_configs.push_back(std::move(*parsed_config));
-    }
-  }
-  if (!errors.empty()) {
-    return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
+  for (auto& parser : registered_parsers_) {
+    parsed_global_configs.push_back(
+        parser->ParseGlobalParams(args, json, errors));
   }
-  return std::move(parsed_global_configs);
+  return parsed_global_configs;
 }
 
-absl::StatusOr<ServiceConfigParser::ParsedConfigVector>
+ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParsePerMethodParameters(const ChannelArgs& args,
-                                              const Json& json) const {
+                                              const Json& json,
+                                              ValidationErrors* errors) const {
   ParsedConfigVector parsed_method_configs;
-  std::vector<std::string> errors;
-  for (size_t i = 0; i < registered_parsers_.size(); ++i) {
-    auto parsed_config =
-        registered_parsers_[i]->ParsePerMethodParams(args, json);
-    if (!parsed_config.ok()) {
-      errors.emplace_back(parsed_config.status().message());
-    } else {
-      parsed_method_configs.push_back(std::move(*parsed_config));
-    }
-  }
-  if (!errors.empty()) {
-    return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
+  for (auto& parser : registered_parsers_) {
+    parsed_method_configs.push_back(
+        parser->ParsePerMethodParams(args, json, errors));
   }
-  return std::move(parsed_method_configs);
+  return parsed_method_configs;
 }
 
 size_t ServiceConfigParser::GetParserIndex(absl::string_view name) const {

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

@@ -26,10 +26,10 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -52,13 +52,15 @@ class ServiceConfigParser {
 
     virtual absl::string_view name() const = 0;
 
-    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParseGlobalParams(
-        const ChannelArgs& /*args*/, const Json& /*json*/) {
+    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/,
+        ValidationErrors* /*errors*/) {
       return nullptr;
     }
 
-    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParsePerMethodParams(
-        const ChannelArgs& /*args*/, const Json& /*json*/) {
+    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/,
+        ValidationErrors* /*errors*/) {
       return nullptr;
     }
   };
@@ -80,11 +82,13 @@ class ServiceConfigParser {
     ServiceConfigParserList registered_parsers_;
   };
 
-  absl::StatusOr<ParsedConfigVector> ParseGlobalParameters(
-      const ChannelArgs& args, const Json& json) const;
+  ParsedConfigVector ParseGlobalParameters(const ChannelArgs& args,
+                                           const Json& json,
+                                           ValidationErrors* errors) const;
 
-  absl::StatusOr<ParsedConfigVector> ParsePerMethodParameters(
-      const ChannelArgs& args, const Json& json) const;
+  ParsedConfigVector ParsePerMethodParameters(const ChannelArgs& args,
+                                              const Json& json,
+                                              ValidationErrors* errors) const;
 
   // Return the index for a given registered parser.
   // If there is an error, return -1.
@@ -98,4 +102,4 @@ class ServiceConfigParser {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H */
+#endif  // GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_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_refcount.h"
+#include "src/core/lib/slice/slice.h"
 
 /* --- Constants. --- */
 
@@ -234,6 +234,6 @@ grpc_slice grpc_base64_decode_with_len(const char* b64, size_t b64_len,
   return result;
 
 fail:
-  grpc_slice_unref_internal(result);
+  grpc_core::CSliceUnref(result);
   return grpc_empty_slice();
 }

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

@@ -30,7 +30,7 @@
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
@@ -494,3 +494,9 @@ grpc_slice grpc_slice_dup(grpc_slice a) {
          GRPC_SLICE_LENGTH(a));
   return copy;
 }
+
+grpc_slice grpc_slice_ref(grpc_slice slice) {
+  return grpc_core::CSliceRef(slice);
+}
+
+void grpc_slice_unref(grpc_slice slice) { grpc_core::CSliceUnref(slice); }

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

@@ -31,7 +31,6 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
 
 // Herein lies grpc_core::Slice and its team of thin wrappers around grpc_slice.
 // They aim to keep you safe by providing strong guarantees around lifetime and
@@ -53,6 +52,19 @@
 
 namespace grpc_core {
 
+inline const grpc_slice& CSliceRef(const grpc_slice& slice) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
+    slice.refcount->Ref();
+  }
+  return slice;
+}
+
+inline void CSliceUnref(const grpc_slice& slice) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
+    slice.refcount->Unref();
+  }
+}
+
 namespace slice_detail {
 
 // Returns an empty slice.
@@ -110,7 +122,7 @@ class BaseSlice {
     return grpc_slice_is_equivalent(slice_, other.slice_);
   }
 
-  uint32_t Hash() const { return grpc_slice_hash_internal(slice_); }
+  uint32_t Hash() const { return grpc_slice_hash(slice_); }
 
  protected:
   BaseSlice() : slice_(EmptySlice()) {}
@@ -249,7 +261,7 @@ class MutableSlice : public slice_detail::BaseSlice,
       : slice_detail::BaseSlice(slice) {
     GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
   }
-  ~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+  ~MutableSlice() { CSliceUnref(c_slice()); }
 
   MutableSlice(const MutableSlice&) = delete;
   MutableSlice& operator=(const MutableSlice&) = delete;
@@ -284,7 +296,8 @@ class Slice : public slice_detail::BaseSlice,
               public slice_detail::StaticConstructors<Slice> {
  public:
   Slice() = default;
-  ~Slice() { grpc_slice_unref_internal(c_slice()); }
+  ~Slice() { CSliceUnref(c_slice()); }
+
   explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {}
   explicit Slice(slice_detail::BaseSlice&& other)
       : slice_detail::BaseSlice(other.TakeCSlice()) {}
@@ -326,7 +339,7 @@ class Slice : public slice_detail::BaseSlice,
     if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
       return Slice(grpc_slice_copy(c_slice()));
     }
-    return Slice(grpc_slice_ref_internal(c_slice()));
+    return Ref();
   }
 
   // TakeMutable returns a MutableSlice, and leaves the current slice in an
@@ -365,7 +378,7 @@ class Slice : public slice_detail::BaseSlice,
     return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
   }
 
-  Slice Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+  Slice Ref() const { return Slice(CSliceRef(c_slice())); }
 
   Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }