grpc 1.39.0.pre1 → 1.41.0.pre2

data/src/core/ext/filters/client_channel/retry_service_config.cc

@@ -159,9 +159,9 @@ RetryServiceConfigParser::ParseGlobalParams(const grpc_channel_args* /*args*/,
 namespace {
 
 grpc_error_handle ParseRetryPolicy(
-    const Json& json, int* max_attempts, grpc_millis* initial_backoff,
-    grpc_millis* max_backoff, float* backoff_multiplier,
-    StatusCodeSet* retryable_status_codes,
+    const grpc_channel_args* args, const Json& json, int* max_attempts,
+    grpc_millis* initial_backoff, grpc_millis* max_backoff,
+    float* backoff_multiplier, StatusCodeSet* retryable_status_codes,
     absl::optional<grpc_millis>* per_attempt_recv_timeout) {
   if (json.type() != Json::Type::OBJECT) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -251,28 +251,38 @@ grpc_error_handle ParseRetryPolicy(
     }
   }
   // Parse perAttemptRecvTimeout.
-  it = json.object_value().find("perAttemptRecvTimeout");
-  if (it != json.object_value().end()) {
-    grpc_millis per_attempt_recv_timeout_value;
-    if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:perAttemptRecvTimeout error:type must be STRING of the "
-          "form given by google.proto.Duration."));
-    } else {
-      *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
-      // TODO(roth): As part of implementing hedging, relax this check such
-      // that we allow a value of 0 if a hedging policy is specified.
-      if (per_attempt_recv_timeout_value == 0) {
+  if (grpc_channel_args_find_bool(args, GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING,
+                                  false)) {
+    it = json.object_value().find("perAttemptRecvTimeout");
+    if (it != json.object_value().end()) {
+      grpc_millis per_attempt_recv_timeout_value;
+      if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:perAttemptRecvTimeout error:must be greater than 0"));
+            "field:perAttemptRecvTimeout error:type must be STRING of the "
+            "form given by google.proto.Duration."));
+      } else {
+        *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
+        // TODO(roth): As part of implementing hedging, relax this check such
+        // that we allow a value of 0 if a hedging policy is specified.
+        if (per_attempt_recv_timeout_value == 0) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:perAttemptRecvTimeout error:must be greater than 0"));
+        }
       }
+    } else if (retryable_status_codes->Empty()) {
+      // If perAttemptRecvTimeout not present, retryableStatusCodes must be
+      // non-empty.
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty if "
+          "perAttemptRecvTimeout not present"));
+    }
+  } else {
+    // Hedging not enabled, so the error message for
+    // retryableStatusCodes unset should be different.
+    if (retryable_status_codes->Empty()) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty"));
     }
-  } else if (retryable_status_codes->Empty()) {
-    // If perAttemptRecvTimeout not present, retryableStatusCodes must be
-    // non-empty.
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryableStatusCodes error:must be non-empty if "
-        "perAttemptRecvTimeout not present"));
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
 }
@@ -280,9 +290,9 @@ grpc_error_handle ParseRetryPolicy(
 }  // namespace
 
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
-RetryServiceConfigParser::ParsePerMethodParams(
-    const grpc_channel_args* /*args*/, const Json& json,
-    grpc_error_handle* error) {
+RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
+                                               const Json& json,
+                                               grpc_error_handle* error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   // Parse retry policy.
   auto it = json.object_value().find("retryPolicy");
@@ -293,7 +303,7 @@ RetryServiceConfigParser::ParsePerMethodParams(
   float backoff_multiplier = 0;
   StatusCodeSet retryable_status_codes;
   absl::optional<grpc_millis> per_attempt_recv_timeout;
-  *error = ParseRetryPolicy(it->second, &max_attempts, &initial_backoff,
+  *error = ParseRetryPolicy(args, it->second, &max_attempts, &initial_backoff,
                             &max_backoff, &backoff_multiplier,
                             &retryable_status_codes, &per_attempt_recv_timeout);
   if (*error != GRPC_ERROR_NONE) return nullptr;

data/src/core/ext/filters/client_channel/retry_service_config.h

@@ -83,7 +83,7 @@ class RetryServiceConfigParser : public ServiceConfigParser::Parser {
       grpc_error_handle* error) override;
 
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const grpc_channel_args* /*args*/, const Json& json,
+      const grpc_channel_args* args, const Json& json,
       grpc_error_handle* error) override;
 
   static size_t ParserIndex();

data/src/core/ext/filters/client_channel/service_config_call_data.h

@@ -23,6 +23,7 @@
 
 #include "absl/strings/string_view.h"
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/channel/context.h"
@@ -39,11 +40,13 @@ class ServiceConfigCallData {
   ServiceConfigCallData(
       RefCountedPtr<ServiceConfig> service_config,
       const ServiceConfigParser::ParsedConfigVector* method_configs,
-      std::map<const char*, absl::string_view> call_attributes,
+      ConfigSelector::CallAttributes call_attributes,
+      ConfigSelector::CallDispatchController* call_dispatch_controller,
       grpc_call_context_element* call_context)
       : service_config_(std::move(service_config)),
         method_configs_(method_configs),
-        call_attributes_(std::move(call_attributes)) {
+        call_attributes_(std::move(call_attributes)),
+        call_dispatch_controller_(call_dispatch_controller) {
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
   }
@@ -53,7 +56,7 @@ class ServiceConfigCallData {
       const ServiceConfigParser::ParsedConfigVector* method_configs,
       grpc_call_context_element* call_context)
       : ServiceConfigCallData(std::move(service_config), method_configs, {},
-                              call_context) {}
+                              nullptr, call_context) {}
 
   ServiceConfig* service_config() { return service_config_.get(); }
 
@@ -70,15 +73,52 @@ class ServiceConfigCallData {
     return call_attributes_;
   }
 
+  ConfigSelector::CallDispatchController* call_dispatch_controller() {
+    return &call_dispatch_controller_;
+  }
+
  private:
+  // A wrapper for the CallDispatchController returned by the ConfigSelector.
+  // Handles the case where the ConfigSelector doees not return any
+  // CallDispatchController.
+  // Also ensures that we call Commit() at most once, which allows the
+  // client channel code to call Commit() when the call is complete in case
+  // it wasn't called earlier, without needing to know whether or not it was.
+  class SingleCommitCallDispatchController
+      : public ConfigSelector::CallDispatchController {
+   public:
+    explicit SingleCommitCallDispatchController(
+        ConfigSelector::CallDispatchController* call_dispatch_controller)
+        : call_dispatch_controller_(call_dispatch_controller) {}
+
+    bool ShouldRetry() override {
+      if (call_dispatch_controller_ != nullptr) {
+        return call_dispatch_controller_->ShouldRetry();
+      }
+      return true;
+    }
+
+    void Commit() override {
+      if (call_dispatch_controller_ != nullptr && !commit_called_) {
+        call_dispatch_controller_->Commit();
+        commit_called_ = true;
+      }
+    }
+
+   private:
+    ConfigSelector::CallDispatchController* call_dispatch_controller_;
+    bool commit_called_ = false;
+  };
+
   static void Destroy(void* ptr) {
     ServiceConfigCallData* self = static_cast<ServiceConfigCallData*>(ptr);
     self->~ServiceConfigCallData();
   }
 
   RefCountedPtr<ServiceConfig> service_config_;
-  const ServiceConfigParser::ParsedConfigVector* method_configs_ = nullptr;
-  std::map<const char*, absl::string_view> call_attributes_;
+  const ServiceConfigParser::ParsedConfigVector* method_configs_;
+  ConfigSelector::CallAttributes call_attributes_;
+  SingleCommitCallDispatchController call_dispatch_controller_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -20,9 +20,10 @@
 
 #include <limits.h>
 
+#include <atomic>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/http2_errors.h"
@@ -159,8 +160,8 @@ class ChannelData {
 
   // Member data used to track the state of channel.
   grpc_millis last_idle_time_;
-  Atomic<intptr_t> call_count_{0};
-  Atomic<ChannelState> state_{IDLE};
+  std::atomic<intptr_t> call_count_{0};
+  std::atomic<ChannelState> state_{IDLE};
 
   // Idle timer and its callback closure.
   grpc_timer idle_timer_;
@@ -201,20 +202,21 @@ void ChannelData::StartTransportOp(grpc_channel_element* elem,
 }
 
 void ChannelData::IncreaseCallCount() {
-  const intptr_t previous_value = call_count_.FetchAdd(1, MemoryOrder::RELAXED);
+  const intptr_t previous_value =
+      call_count_.fetch_add(1, std::memory_order_relaxed);
   GRPC_IDLE_FILTER_LOG("call counter has increased to %" PRIuPTR,
                        previous_value + 1);
   if (previous_value == 0) {
     // This call is the one that makes the channel busy.
     // Loop here to make sure the previous decrease operation has finished.
-    ChannelState state = state_.Load(MemoryOrder::RELAXED);
+    ChannelState state = state_.load(std::memory_order_relaxed);
     while (true) {
       switch (state) {
         // Timer has not been set. Switch to CALLS_ACTIVE.
         case IDLE:
           // In this case, no other threads will modify the state, so we can
           // just store the value.
-          state_.Store(CALLS_ACTIVE, MemoryOrder::RELAXED);
+          state_.store(CALLS_ACTIVE, std::memory_order_relaxed);
           return;
         // Timer has been set. Switch to TIMER_PENDING_CALLS_ACTIVE.
         case TIMER_PENDING:
@@ -222,17 +224,17 @@ void ChannelData::IncreaseCallCount() {
           // At this point, the state may have been switched to IDLE by the
           // idle timer callback. Therefore, use CAS operation to change the
           // state atomically.
-          // Use MemoryOrder::ACQUIRE on success to ensure last_idle_time_ has
-          // been properly set in DecreaseCallCount().
-          if (state_.CompareExchangeWeak(&state, TIMER_PENDING_CALLS_ACTIVE,
-                                         MemoryOrder::ACQUIRE,
-                                         MemoryOrder::RELAXED)) {
+          // Use std::memory_order_acquire on success to ensure last_idle_time_
+          // has been properly set in DecreaseCallCount().
+          if (state_.compare_exchange_weak(state, TIMER_PENDING_CALLS_ACTIVE,
+                                           std::memory_order_acquire,
+                                           std::memory_order_relaxed)) {
             return;
           }
           break;
         default:
           // The state has not been switched to desired value yet, try again.
-          state = state_.Load(MemoryOrder::RELAXED);
+          state = state_.load(std::memory_order_relaxed);
           break;
       }
     }
@@ -240,16 +242,17 @@ void ChannelData::IncreaseCallCount() {
 }
 
 void ChannelData::DecreaseCallCount() {
-  const intptr_t previous_value = call_count_.FetchSub(1, MemoryOrder::RELAXED);
+  const intptr_t previous_value =
+      call_count_.fetch_sub(1, std::memory_order_relaxed);
   GRPC_IDLE_FILTER_LOG("call counter has decreased to %" PRIuPTR,
                        previous_value - 1);
   if (previous_value == 1) {
     // This call is the one that makes the channel idle.
-    // last_idle_time_ does not need to be Atomic<> because busy-loops in
+    // last_idle_time_ does not need to be std::atomic<> because busy-loops in
     // IncreaseCallCount(), DecreaseCallCount() and IdleTimerCallback() will
     // prevent multiple threads from simultaneously accessing this variable.
     last_idle_time_ = ExecCtx::Get()->Now();
-    ChannelState state = state_.Load(MemoryOrder::RELAXED);
+    ChannelState state = state_.load(std::memory_order_relaxed);
     while (true) {
       switch (state) {
         // Timer has not been set. Set the timer and switch to TIMER_PENDING
@@ -257,7 +260,7 @@ void ChannelData::DecreaseCallCount() {
           // Release store here to make other threads see the updated value of
           // last_idle_time_.
           StartIdleTimer();
-          state_.Store(TIMER_PENDING, MemoryOrder::RELEASE);
+          state_.store(TIMER_PENDING, std::memory_order_release);
           return;
         // Timer has been set. Switch to
         // TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START
@@ -267,15 +270,15 @@ void ChannelData::DecreaseCallCount() {
           // state atomically.
           // Release store here to make the idle timer callback see the updated
           // value of last_idle_time_ to properly reset the idle timer.
-          if (state_.CompareExchangeWeak(
-                  &state, TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
-                  MemoryOrder::RELEASE, MemoryOrder::RELAXED)) {
+          if (state_.compare_exchange_weak(
+                  state, TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
+                  std::memory_order_release, std::memory_order_relaxed)) {
             return;
           }
           break;
         default:
           // The state has not been switched to desired value yet, try again.
-          state = state_.Load(MemoryOrder::RELAXED);
+          state = state_.load(std::memory_order_relaxed);
           break;
       }
     }
@@ -313,38 +316,41 @@ void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
     return;
   }
   bool finished = false;
-  ChannelState state = chand->state_.Load(MemoryOrder::RELAXED);
+  ChannelState state = chand->state_.load(std::memory_order_relaxed);
   while (!finished) {
     switch (state) {
       case TIMER_PENDING:
         // Change the state to PROCESSING to block IncreaseCallCout() until the
         // EnterIdle() operation finishes, preventing mistakenly entering IDLE
         // when active RPC exists.
-        finished = chand->state_.CompareExchangeWeak(
-            &state, PROCESSING, MemoryOrder::ACQUIRE, MemoryOrder::RELAXED);
+        finished = chand->state_.compare_exchange_weak(
+            state, PROCESSING, std::memory_order_acquire,
+            std::memory_order_relaxed);
         if (finished) {
           chand->EnterIdle();
-          chand->state_.Store(IDLE, MemoryOrder::RELAXED);
+          chand->state_.store(IDLE, std::memory_order_relaxed);
         }
         break;
       case TIMER_PENDING_CALLS_ACTIVE:
-        finished = chand->state_.CompareExchangeWeak(
-            &state, CALLS_ACTIVE, MemoryOrder::RELAXED, MemoryOrder::RELAXED);
+        finished = chand->state_.compare_exchange_weak(
+            state, CALLS_ACTIVE, std::memory_order_relaxed,
+            std::memory_order_relaxed);
         break;
       case TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START:
         // Change the state to PROCESSING to block IncreaseCallCount() until the
         // StartIdleTimer() operation finishes, preventing mistakenly restarting
         // the timer after grpc_timer_cancel() when shutdown.
-        finished = chand->state_.CompareExchangeWeak(
-            &state, PROCESSING, MemoryOrder::ACQUIRE, MemoryOrder::RELAXED);
+        finished = chand->state_.compare_exchange_weak(
+            state, PROCESSING, std::memory_order_acquire,
+            std::memory_order_relaxed);
         if (finished) {
           chand->StartIdleTimer();
-          chand->state_.Store(TIMER_PENDING, MemoryOrder::RELAXED);
+          chand->state_.store(TIMER_PENDING, std::memory_order_relaxed);
         }
         break;
       default:
         // The state has not been switched to desired value yet, try again.
-        state = chand->state_.Load(MemoryOrder::RELAXED);
+        state = chand->state_.load(std::memory_order_relaxed);
         break;
     }
   }

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -18,6 +18,8 @@
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 
+#include <atomic>
+
 #include "absl/strings/numbers.h"
 
 #include <grpc/support/alloc.h>
@@ -28,7 +30,6 @@
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -40,9 +41,9 @@ TraceFlag grpc_fault_injection_filter_trace(false, "fault_injection_filter");
 
 namespace {
 
-Atomic<uint32_t> g_active_faults{0};
+std::atomic<uint32_t> g_active_faults{0};
 static_assert(
-    std::is_trivially_destructible<Atomic<uint32_t>>::value,
+    std::is_trivially_destructible<std::atomic<uint32_t>>::value,
     "the active fault counter needs to have a trivially destructible type");
 
 inline int GetLinkedMetadatumValueInt(grpc_linked_mdelem* md) {
@@ -140,7 +141,7 @@ class CallData {
 
   // Finishes the fault injection, should only be called once.
   void FaultInjectionFinished() {
-    g_active_faults.FetchSub(1, MemoryOrder::RELAXED);
+    g_active_faults.fetch_sub(1, std::memory_order_relaxed);
   }
 
   // This is a callback that will be invoked after the delay timer is up.
@@ -400,10 +401,11 @@ void CallData::DecideWhetherToInjectFaults(
 }
 
 bool CallData::HaveActiveFaultsQuota(bool increment) {
-  if (g_active_faults.Load(MemoryOrder::ACQUIRE) >= fi_policy_->max_faults) {
+  if (g_active_faults.load(std::memory_order_acquire) >=
+      fi_policy_->max_faults) {
     return false;
   }
-  if (increment) g_active_faults.FetchAdd(1, MemoryOrder::RELAXED);
+  if (increment) g_active_faults.fetch_add(1, std::memory_order_relaxed);
   return true;
 }
 
@@ -428,12 +430,6 @@ void CallData::DelayBatch(grpc_call_element* elem,
   MutexLock lock(&delay_mu_);
   delayed_batch_ = batch;
   resume_batch_canceller_ = new ResumeBatchCanceller(elem);
-  // Without this line, ExecCtx::Get()->Now() will return a cached timestamp. If
-  // there are thousands of RPCs happen on one thread, we might observe ms-level
-  // error in Now(). This could mean the construction of RPC object is
-  // microseconds earlier than the filter execution. But we still haven't found
-  // the root cause. Read more: https://github.com/grpc/grpc/pull/25738.
-  ExecCtx::Get()->InvalidateNow();
   grpc_millis resume_time = ExecCtx::Get()->Now() + fi_policy_->delay;
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, ResumeBatch, elem,
                     grpc_schedule_on_exec_ctx);

data/src/core/ext/filters/fault_injection/service_config_parser.cc

@@ -22,6 +22,7 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -44,10 +45,8 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
         fault_injection_policy;
     std::vector<grpc_error_handle> sub_error_list;
     if (policies_json_array[i].type() != Json::Type::OBJECT) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrCat("faultInjectionPolicy index ", i,
-                       " is not a JSON object")
-              .c_str()));
+      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "faultInjectionPolicy index ", i, " is not a JSON object")));
       continue;
     }
     const Json::Object& json_object = policies_json_array[i].object_value();
@@ -133,15 +132,9 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
       }
     }
     if (!sub_error_list.empty()) {
-      // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
-      // string is not static in this case.
-      grpc_error_handle error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          absl::StrCat("failed to parse faultInjectionPolicy index ", i)
-              .c_str());
-      for (size_t i = 0; i < sub_error_list.size(); ++i) {
-        error = grpc_error_add_child(error, sub_error_list[i]);
-      }
-      error_list->push_back(error);
+      error_list->push_back(GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
+          absl::StrCat("failed to parse faultInjectionPolicy index ", i),
+          &sub_error_list));
     }
     policies.push_back(std::move(fault_injection_policy));
   }

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/client/http_client_filter.h"
+
 #include <stdint.h>
 #include <string.h>
 
@@ -30,7 +32,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -142,7 +143,7 @@ static grpc_error_handle client_filter_incoming_metadata(
   }
 
   if (b->idx.named.grpc_message != nullptr) {
-    grpc_slice pct_decoded_msg = grpc_permissive_percent_decode_slice(
+    grpc_slice pct_decoded_msg = grpc_core::PermissivePercentDecodeSlice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md));
     if (grpc_slice_is_equivalent(pct_decoded_msg,
                                  GRPC_MDVALUE(b->idx.named.grpc_message->md))) {
@@ -232,6 +233,9 @@ static void send_message_on_complete(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);
   calld->send_message_cache.Destroy();
+  // Set the batch's send_message bit back to true, so the retry code
+  // above knows what was in this batch.
+  calld->send_message_batch->send_message = true;
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->original_send_message_on_complete,
                           GRPC_ERROR_REF(error));
@@ -474,8 +478,8 @@ static void http_client_start_transport_stream_op_batch(
 
 done:
   if (error != GRPC_ERROR_NONE) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        calld->send_message_batch, error, calld->call_combiner);
+    grpc_transport_stream_op_batch_finish_with_failure(batch, error,
+                                                       calld->call_combiner);
   } else if (!batch_will_be_handled_asynchronously) {
     grpc_call_next_op(elem, batch);
   }

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/client_authority_filter.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <string.h>
@@ -26,7 +28,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/http/client_authority_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"

data/src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
+
 #include <assert.h>
 #include <string.h>
 
@@ -28,7 +30,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/compression/algorithm_metadata.h"
 #include "src/core/lib/compression/compression_args.h"

data/src/core/ext/filters/http/message_compress/message_decompress_filter.cc

@@ -24,13 +24,13 @@
 #include <string.h>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "absl/strings/str_format.h"
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/compression/algorithm_metadata.h"
@@ -196,12 +196,12 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
       if (calld->max_recv_message_length_ >= 0 &&
           (*calld->recv_message_)->length() >
               static_cast<uint32_t>(calld->max_recv_message_length_)) {
-        std::string message_string = absl::StrFormat(
-            "Received message larger than max (%u vs. %d)",
-            (*calld->recv_message_)->length(), calld->max_recv_message_length_);
         GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
         calld->error_ = grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string.c_str()),
+            GRPC_ERROR_CREATE_FROM_CPP_STRING(
+                absl::StrFormat("Received message larger than max (%u vs. %d)",
+                                (*calld->recv_message_)->length(),
+                                calld->max_recv_message_length_)),
             GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
         return calld->ContinueRecvMessageReadyCallback(
             GRPC_ERROR_REF(calld->error_));
@@ -260,11 +260,10 @@ void CallData::FinishRecvMessage() {
   if (grpc_msg_decompress(algorithm_, &recv_slices_, &decompressed_slices) ==
       0) {
     GPR_DEBUG_ASSERT(error_ == GRPC_ERROR_NONE);
-    error_ = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+    error_ = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("Unexpected error decompressing data for algorithm with "
                      "enum value ",
-                     algorithm_)
-            .c_str());
+                     algorithm_));
     grpc_slice_buffer_destroy_internal(&decompressed_slices);
   } else {
     uint32_t recv_flags =

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -20,9 +20,11 @@
 
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <string.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -103,9 +105,9 @@ struct channel_data {
 
 static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
   if (b->idx.named.grpc_message != nullptr) {
-    grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
+    grpc_slice pct_encoded_msg = grpc_core::PercentEncodeSlice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md),
-        grpc_compatible_percent_encoding_unreserved_bytes);
+        grpc_core::PercentEncodingType::Compatible);
     if (grpc_slice_is_equivalent(pct_encoded_msg,
                                  GRPC_MDVALUE(b->idx.named.grpc_message->md))) {
       grpc_slice_unref_internal(pct_encoded_msg);

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -203,11 +203,9 @@ static void recv_message_ready(void* user_data, grpc_error_handle error) {
       (*calld->recv_message)->length() >
           static_cast<size_t>(calld->limits.max_recv_size)) {
     grpc_error_handle new_error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-            absl::StrFormat("Received message larger than max (%u vs. %d)",
-                            (*calld->recv_message)->length(),
-                            calld->limits.max_recv_size)
-                .c_str()),
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+            "Received message larger than max (%u vs. %d)",
+            (*calld->recv_message)->length(), calld->limits.max_recv_size)),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
     error = grpc_error_add_child(GRPC_ERROR_REF(error), new_error);
     GRPC_ERROR_UNREF(calld->error);
@@ -264,14 +262,12 @@ static void message_size_start_transport_stream_op_batch(
           static_cast<size_t>(calld->limits.max_send_size)) {
     grpc_transport_stream_op_batch_finish_with_failure(
         op,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-                absl::StrFormat(
-                    "Sent message larger than max (%u vs. %d)",
-                    op->payload->send_message.send_message->length(),
-                    calld->limits.max_send_size)
-                    .c_str()),
-            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED),
+        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+                               "Sent message larger than max (%u vs. %d)",
+                               op->payload->send_message.send_message->length(),
+                               calld->limits.max_send_size)),
+                           GRPC_ERROR_INT_GRPC_STATUS,
+                           GRPC_STATUS_RESOURCE_EXHAUSTED),
         calld->call_combiner);
     return;
   }