grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -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>
 
@@ -27,9 +27,9 @@
 #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. --- */
+// --- Constants. ---
 
 static const int8_t base64_bytes[] = {
     -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
@@ -54,7 +54,7 @@ static const char base64_url_safe_chars[] =
 #define GRPC_BASE64_MULTILINE_LINE_LEN 76
 #define GRPC_BASE64_MULTILINE_NUM_BLOCKS (GRPC_BASE64_MULTILINE_LINE_LEN / 4)
 
-/* --- base64 functions. --- */
+// --- base64 functions. ---
 
 char* grpc_base64_encode(const void* vdata, size_t data_size, int url_safe,
                          int multiline) {
@@ -86,7 +86,7 @@ void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
   size_t num_blocks = 0;
   size_t i = 0;
 
-  /* Encode each block. */
+  // Encode each block.
   while (data_size >= 3) {
     *current++ = base64_chars[(data[i] >> 2) & 0x3F];
     *current++ =
@@ -104,7 +104,7 @@ void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
     }
   }
 
-  /* Take care of the tail. */
+  // Take care of the tail.
   if (data_size == 2) {
     *current++ = base64_chars[(data[i] >> 2) & 0x3F];
     *current++ =
@@ -147,7 +147,7 @@ static int decode_group(const unsigned char* codes, size_t num_codes,
                         unsigned char* result, size_t* result_offset) {
   GPR_ASSERT(num_codes <= 4);
 
-  /* Short end groups that may not have padding. */
+  // Short end groups that may not have padding.
   if (num_codes == 1) {
     gpr_log(GPR_ERROR, "Invalid group. Must be at least 2 bytes.");
     return 0;
@@ -161,7 +161,7 @@ static int decode_group(const unsigned char* codes, size_t num_codes,
     return 1;
   }
 
-  /* Regular 4 byte groups with padding or not. */
+  // Regular 4 byte groups with padding or not.
   GPR_ASSERT(num_codes == 4);
   if (codes[0] == GRPC_BASE64_PAD_BYTE || codes[1] == GRPC_BASE64_PAD_BYTE) {
     gpr_log(GPR_ERROR, "Invalid padding detected.");
@@ -177,7 +177,7 @@ static int decode_group(const unsigned char* codes, size_t num_codes,
   } else if (codes[3] == GRPC_BASE64_PAD_BYTE) {
     decode_two_chars(codes, result, result_offset);
   } else {
-    /* No padding. */
+    // No padding.
     uint32_t packed = (static_cast<uint32_t>(codes[0]) << 18) |
                       (static_cast<uint32_t>(codes[1]) << 12) |
                       (static_cast<uint32_t>(codes[2]) << 6) | codes[3];
@@ -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();
 }