grpc 1.40.0 → 1.41.0

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

@@ -30,36 +30,37 @@
 
 #include <stdbool.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/slice.h>
 
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   grpc_percent_encode_slice, grpc_strict_percent_decode_slice).
-   Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
-   */
-extern const uint8_t grpc_url_percent_encoding_unreserved_bytes[256 / 8];
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   grpc_percent_encode_slice, grpc_strict_percent_decode_slice).
-   Flags ascii7 non-control characters excluding '%' as unreserved bytes for the
-   percent encoding routines */
-extern const uint8_t grpc_compatible_percent_encoding_unreserved_bytes[256 / 8];
+namespace grpc_core {
+
+enum class PercentEncodingType {
+  // Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
+  URL,
+  // Flags ascii7 non-control characters excluding '%' as unreserved bytes for
+  // the
+  // percent encoding routines
+  Compatible
+};
+
+// Percent-encode a slice, returning the new slice (this cannot fail):
+// unreserved_bytes is a bitfield indicating which bytes are considered
+// unreserved and thus do not need percent encoding
+grpc_slice PercentEncodeSlice(const grpc_slice& slice,
+                              PercentEncodingType type);
+// Percent-decode a slice, strictly.
+// If the input is legal (contains no unreserved bytes, and legal % encodings),
+// returns the decoded slice.
+// If the input is not legal, returns {}.
+absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
+                                              PercentEncodingType type);
+// Percent-decode a slice, permissively.
+// If a % triplet can not be decoded, pass it through verbatim.
+// This cannot fail.
+grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in);
 
-/* Percent-encode a slice, returning the new slice (this cannot fail):
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-grpc_slice grpc_percent_encode_slice(const grpc_slice& slice,
-                                     const uint8_t* unreserved_bytes);
-/* Percent-decode a slice, strictly.
-   If the input is legal (contains no unreserved bytes, and legal % encodings),
-   returns true and sets *slice_out to the decoded slice.
-   If the input is not legal, returns false and leaves *slice_out untouched.
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-bool grpc_strict_percent_decode_slice(const grpc_slice& slice_in,
-                                      const uint8_t* unreserved_bytes,
-                                      grpc_slice* slice_out);
-/* Percent-decode a slice, permissively.
-   If a % triplet can not be decoded, pass it through verbatim.
-   This cannot fail. */
-grpc_slice grpc_permissive_percent_decode_slice(const grpc_slice& slice_in);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */

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

@@ -18,17 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/slice/slice_internal.h"
+#include <string.h>
 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include <string.h>
-
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/slice/slice_internal.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));

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

@@ -18,10 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice_buffer.h>
-
 #include <string.h>
 
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 

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

@@ -18,9 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_utils.h"
-
 #include <inttypes.h>
 #include <string.h>
 
@@ -31,7 +28,9 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/iomgr_internal.h" /* for iomgr_abort_on_leaks() */
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 #define LOG2_SHARD_COUNT 5

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

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
+#include <string.h>
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
-#include <string.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/gprpp/memory.h"

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

@@ -18,7 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 
+#include "src/core/lib/debug/trace.h"
+
 grpc_core::TraceFlag grpc_api_trace(false, "api");

data/src/core/lib/surface/api_trace.h

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/support/log.h>
+
 #include "src/core/lib/debug/trace.h"
 
 extern grpc_core::TraceFlag grpc_api_trace;

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

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/byte_buffer_reader.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>

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/surface/call.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
@@ -51,7 +53,6 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/call_test_only.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -105,13 +106,13 @@ struct batch_control {
   } completion_data;
   grpc_closure start_batch;
   grpc_closure finish_batch;
-  grpc_core::Atomic<intptr_t> steps_to_complete;
+  std::atomic<intptr_t> steps_to_complete{0};
   gpr_atm batch_error = reinterpret_cast<gpr_atm>(GRPC_ERROR_NONE);
   void set_num_steps_to_complete(uintptr_t steps) {
-    steps_to_complete.Store(steps, grpc_core::MemoryOrder::RELEASE);
+    steps_to_complete.store(steps, std::memory_order_release);
   }
   bool completed_batch_step() {
-    return steps_to_complete.FetchSub(1, grpc_core::MemoryOrder::ACQ_REL) == 1;
+    return steps_to_complete.fetch_sub(1, std::memory_order_acq_rel) == 1;
   }
 };
 
@@ -1065,10 +1066,10 @@ static void recv_trailing_filter(void* args, grpc_metadata_batch* b,
     grpc_error_handle error = GRPC_ERROR_NONE;
     if (status_code != GRPC_STATUS_OK) {
       char* peer = grpc_call_get_peer(call);
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              absl::StrCat("Error received from peer ", peer).c_str()),
-          GRPC_ERROR_INT_GRPC_STATUS, static_cast<intptr_t>(status_code));
+      error = grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+                                     "Error received from peer ", peer)),
+                                 GRPC_ERROR_INT_GRPC_STATUS,
+                                 static_cast<intptr_t>(status_code));
       gpr_free(peer);
     }
     if (b->idx.named.grpc_message != nullptr) {

data/src/core/lib/surface/call.h

@@ -21,15 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/compression_types.h>
+
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 
-#include <grpc/grpc.h>
-#include <grpc/impl/codegen/compression_types.h>
-
 typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
 

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

@@ -18,11 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 
-#include <string.h>
-
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"

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

@@ -18,8 +18,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/surface/call.h"
-
 #include <inttypes.h>
 
 #include <vector>
@@ -29,8 +27,10 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/surface/call.h"
 
 static void add_metadata(const grpc_metadata* md, size_t count,
                          std::vector<std::string>* b) {

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

@@ -58,12 +58,12 @@ static void destroy_channel(void* arg, grpc_error_handle error);
 
 grpc_channel* grpc_channel_create_with_builder(
     grpc_channel_stack_builder* builder,
-    grpc_channel_stack_type channel_stack_type, grpc_error_handle* error) {
+    grpc_channel_stack_type channel_stack_type,
+    grpc_resource_user* resource_user, size_t preallocated_bytes,
+    grpc_error_handle* error) {
   char* target = gpr_strdup(grpc_channel_stack_builder_get_target(builder));
   grpc_channel_args* args = grpc_channel_args_copy(
       grpc_channel_stack_builder_get_channel_arguments(builder));
-  grpc_resource_user* resource_user =
-      grpc_channel_stack_builder_get_resource_user(builder);
   grpc_channel* channel;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     GRPC_STATS_INC_SERVER_CHANNELS_CREATED();
@@ -84,10 +84,17 @@ grpc_channel* grpc_channel_create_with_builder(
     }
     gpr_free(target);
     grpc_channel_args_destroy(args);
+    if (resource_user != nullptr) {
+      if (preallocated_bytes > 0) {
+        grpc_resource_user_free(resource_user, preallocated_bytes);
+      }
+      grpc_resource_user_unref(resource_user);
+    }
     return nullptr;
   }
   channel->target = target;
   channel->resource_user = resource_user;
+  channel->preallocated_bytes = preallocated_bytes;
   channel->is_client = grpc_channel_stack_type_is_client(channel_stack_type);
   channel->registration_table.Init();
 
@@ -225,6 +232,7 @@ grpc_channel* grpc_channel_create(const char* target,
                                   grpc_channel_stack_type channel_stack_type,
                                   grpc_transport* optional_transport,
                                   grpc_resource_user* resource_user,
+                                  size_t preallocated_bytes,
                                   grpc_error_handle* error) {
   // We need to make sure that grpc_shutdown() does not shut things down
   // until after the channel is destroyed.  However, the channel may not
@@ -259,11 +267,13 @@ grpc_channel* grpc_channel_create(const char* target,
   grpc_channel_args_destroy(args);
   grpc_channel_stack_builder_set_target(builder, target);
   grpc_channel_stack_builder_set_transport(builder, optional_transport);
-  grpc_channel_stack_builder_set_resource_user(builder, resource_user);
   if (!grpc_channel_init_create_stack(builder, channel_stack_type)) {
     grpc_channel_stack_builder_destroy(builder);
     if (resource_user != nullptr) {
-      grpc_resource_user_free(resource_user, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
+      if (preallocated_bytes > 0) {
+        grpc_resource_user_free(resource_user, preallocated_bytes);
+      }
+      grpc_resource_user_unref(resource_user);
     }
     grpc_shutdown();  // Since we won't call destroy_channel().
     return nullptr;
@@ -273,8 +283,8 @@ grpc_channel* grpc_channel_create(const char* target,
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
     CreateChannelzNode(builder);
   }
-  grpc_channel* channel =
-      grpc_channel_create_with_builder(builder, channel_stack_type, error);
+  grpc_channel* channel = grpc_channel_create_with_builder(
+      builder, channel_stack_type, resource_user, preallocated_bytes, error);
   if (channel == nullptr) {
     grpc_shutdown();  // Since we won't call destroy_channel().
   }
@@ -508,8 +518,11 @@ static void destroy_channel(void* arg, grpc_error_handle /*error*/) {
   grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));
   channel->registration_table.Destroy();
   if (channel->resource_user != nullptr) {
-    grpc_resource_user_free(channel->resource_user,
-                            GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
+    if (channel->preallocated_bytes > 0) {
+      grpc_resource_user_free(channel->resource_user,
+                              channel->preallocated_bytes);
+    }
+    grpc_resource_user_unref(channel->resource_user);
   }
   gpr_free(channel->target);
   gpr_free(channel);

data/src/core/lib/surface/channel.h

@@ -30,20 +30,31 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/metadata.h"
 
+/// Creates a grpc_channel.
+///
+/// If the \a resource_user is not null, \a preallocated_bytes may have been
+/// allocated on that resource_user for use by the channel. These bytes will be
+/// freed from the resource_user upon channel destruction.
+///
+/// Takes ownership of a \a resource_user ref.
 grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* args,
                                   grpc_channel_stack_type channel_stack_type,
                                   grpc_transport* optional_transport,
-                                  grpc_resource_user* resource_user = nullptr,
-                                  grpc_error_handle* error = nullptr);
+                                  grpc_resource_user* resource_user,
+                                  size_t preallocated_bytes,
+                                  grpc_error_handle* error);
 
 /** The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
  * is safe to use from within core. */
 void grpc_channel_destroy_internal(grpc_channel* channel);
 
+/// Creates a grpc_channel with a builder. See the description of
+/// \a grpc_channel_create for variable definitions.
 grpc_channel* grpc_channel_create_with_builder(
     grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type,
+    grpc_resource_user* resource_user, size_t preallocated_bytes,
     grpc_error_handle* error = nullptr);
 
 /** Create a call given a grpc_channel, in order to call \a method.
@@ -108,6 +119,7 @@ struct grpc_channel {
 
   gpr_atm call_size_estimate;
   grpc_resource_user* resource_user;
+  size_t preallocated_bytes;
 
   // TODO(vjpai): Once the grpc_channel is allocated via new rather than malloc,
   //              expand the members of the CallRegistrationTable directly into

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

@@ -18,14 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/surface/channel.h"
-
 #include <string.h>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 
 struct ping_result {

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

@@ -18,9 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
 #include "src/core/lib/surface/channel_stack_type.h"
 
+#include <grpc/support/log.h>
+
 bool grpc_channel_stack_type_is_client(grpc_channel_stack_type type) {
   switch (type) {
     case GRPC_CLIENT_CHANNEL: