grpc 1.45.0 → 1.53.0

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 {
@@ -42,43 +48,25 @@ void ServiceConfigParser::Builder::RegisterParser(
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
+ServiceConfigParser::ParseGlobalParameters(const ChannelArgs& args,
                                            const Json& json,
-                                           grpc_error_handle* error) const {
+                                           ValidationErrors* errors) const {
   ParsedConfigVector parsed_global_configs;
-  std::vector<grpc_error_handle> error_list;
-  for (size_t i = 0; i < registered_parsers_.size(); i++) {
-    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) {
-      error_list.push_back(parser_error);
-    }
-    parsed_global_configs.push_back(std::move(parsed_config));
-  }
-  if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("Global Params", &error_list);
+  for (auto& parser : registered_parsers_) {
+    parsed_global_configs.push_back(
+        parser->ParseGlobalParams(args, json, errors));
   }
   return parsed_global_configs;
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
+ServiceConfigParser::ParsePerMethodParameters(const ChannelArgs& args,
                                               const Json& json,
-                                              grpc_error_handle* error) const {
+                                              ValidationErrors* errors) const {
   ParsedConfigVector parsed_method_configs;
-  std::vector<grpc_error_handle> error_list;
-  for (size_t i = 0; i < registered_parsers_.size(); ++i) {
-    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) {
-      error_list.push_back(parser_error);
-    }
-    parsed_method_configs.push_back(std::move(parsed_config));
-  }
-  if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
+  for (auto& parser : registered_parsers_) {
+    parsed_method_configs.push_back(
+        parser->ParsePerMethodParams(args, json, errors));
   }
   return parsed_method_configs;
 }

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

@@ -14,17 +14,22 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
-#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
+#ifndef GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
+#define GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <algorithm>
 #include <memory>
+#include <utility>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/error.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 {
@@ -48,20 +53,14 @@ class ServiceConfigParser {
     virtual absl::string_view name() const = 0;
 
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+        const ChannelArgs& /*args*/, const Json& /*json*/,
+        ValidationErrors* /*errors*/) {
       return nullptr;
     }
 
     virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+        const ChannelArgs& /*args*/, const Json& /*json*/,
+        ValidationErrors* /*errors*/) {
       return nullptr;
     }
   };
@@ -83,13 +82,13 @@ class ServiceConfigParser {
     ServiceConfigParserList registered_parsers_;
   };
 
-  ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
+  ParsedConfigVector ParseGlobalParameters(const ChannelArgs& args,
                                            const Json& json,
-                                           grpc_error_handle* error) const;
+                                           ValidationErrors* errors) const;
 
-  ParsedConfigVector ParsePerMethodParameters(const grpc_channel_args* args,
+  ParsedConfigVector ParsePerMethodParameters(const ChannelArgs& args,
                                               const Json& json,
-                                              grpc_error_handle* error) const;
+                                              ValidationErrors* errors) const;
 
   // Return the index for a given registered parser.
   // If there is an error, return -1.
@@ -103,4 +102,4 @@ class ServiceConfigParser {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_PARSER_H */
+#endif  // GRPC_SRC_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_internal.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();
 }

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

@@ -1,50 +1,52 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_SLICE_B64_H
-#define GRPC_CORE_LIB_SLICE_B64_H
+//
+//
+// 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_SLICE_B64_H
+#define GRPC_SRC_CORE_LIB_SLICE_B64_H
 
 #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
-   the returned char * using gpr_free. Returns NULL on NULL input.
-   TODO(makdharma) : change the flags to bool from int */
+// Encodes data using base64. It is the caller's responsibility to free
+// the returned char * using gpr_free. Returns NULL on NULL input.
+// TODO(makdharma) : change the flags to bool from int
 char* grpc_base64_encode(const void* data, size_t data_size, int url_safe,
                          int multiline);
 
-/* estimate the upper bound on size of base64 encoded data. The actual size
- * is guaranteed to be less than or equal to the size returned here. */
+// estimate the upper bound on size of base64 encoded data. The actual size
+// is guaranteed to be less than or equal to the size returned here.
 size_t grpc_base64_estimate_encoded_size(size_t data_size, int multiline);
 
-/* Encodes data using base64 and write it to memory pointed to by result. It is
- * the caller's responsibility to allocate enough memory in |result| to fit the
- * encoded data. */
+// Encodes data using base64 and write it to memory pointed to by result. It is
+// the caller's responsibility to allocate enough memory in |result| to fit the
+// encoded data.
 void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
                              int url_safe, int multiline);
 
-/* Decodes data according to the base64 specification. Returns an empty
-   slice in case of failure. */
+// Decodes data according to the base64 specification. Returns an empty
+// slice in case of failure.
 grpc_slice grpc_base64_decode(const char* b64, int url_safe);
 
-/* Same as above except that the length is provided by the caller. */
+// Same as above except that the length is provided by the caller.
 grpc_slice grpc_base64_decode_with_len(const char* b64, size_t b64_len,
                                        int url_safe);
 
-#endif /* GRPC_CORE_LIB_SLICE_B64_H */
+#endif  // GRPC_SRC_CORE_LIB_SLICE_B64_H

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

@@ -1,46 +1,40 @@
-/*
- *
- * Copyright 2016 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 2016 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 "src/core/lib/slice/percent_encoding.h"
 
+#include <stdlib.h>
+
 #include <cstdint>
+#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
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_PCTENCODE_CONSTEXPR_FN
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE const
-#endif
 
 namespace grpc_core {
 
 namespace {
 class UrlTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN UrlTable() {
+  constexpr UrlTable() {
     for (int i = 'a'; i <= 'z'; i++) set(i);
     for (int i = 'A'; i <= 'Z'; i++) set(i);
     for (int i = '0'; i <= '9'; i++) set(i);
@@ -51,11 +45,11 @@ class UrlTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+constexpr UrlTable g_url_table;
 
 class CompatibleTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN CompatibleTable() {
+  constexpr CompatibleTable() {
     for (int i = 32; i <= 126; i++) {
       if (i == '%') continue;
       set(i);
@@ -63,7 +57,7 @@ class CompatibleTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+constexpr CompatibleTable g_compatible_table;
 
 // Map PercentEncodingType to a lookup table of legal symbols for that encoding.
 const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {

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

@@ -1,39 +1,33 @@
-/*
- *
- * Copyright 2016 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_PERCENT_ENCODING_H
-#define GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H
-
-/* Percent encoding and decoding of slices.
-   Transforms arbitrary strings into safe-for-transmission strings by using
-   variants of percent encoding (RFC 3986).
-   Two major variants are supplied: one that strictly matches URL encoding,
-     and another which applies percent encoding only to non-http2 header
-     bytes (the 'compatible' variant) */
+//
+//
+// Copyright 2016 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_SRC_CORE_LIB_SLICE_PERCENT_ENCODING_H
+#define GRPC_SRC_CORE_LIB_SLICE_PERCENT_ENCODING_H
+
+// Percent encoding and decoding of slices.
+// Transforms arbitrary strings into safe-for-transmission strings by using
+// variants of percent encoding (RFC 3986).
+// Two major variants are supplied: one that strictly matches URL encoding,
+//   and another which applies percent encoding only to non-http2 header
+//   bytes (the 'compatible' variant)
 
 #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 {
@@ -57,4 +51,4 @@ Slice PermissivePercentDecodeSlice(Slice slice_in);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */
+#endif  // GRPC_SRC_CORE_LIB_SLICE_PERCENT_ENCODING_H