grpc 1.43.1 → 1.44.0.pre2

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

@@ -22,26 +22,24 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
-#include "src/core/ext/service_config/service_config.h"
-#include "src/core/ext/service_config/service_config_call_data.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/service_config/service_config.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/static_metadata.h"
-#include "src/core/lib/transport/status_metadata.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 //
@@ -396,10 +394,8 @@ class RetryFilter::CallData {
     void MaybeSwitchToFastPath();
 
     // Returns true if the call should be retried.
-    // If server_pushback_md is non-null, sets *server_pushback_ms.
     bool ShouldRetry(absl::optional<grpc_status_code> status, bool is_lb_drop,
-                     grpc_mdelem* server_pushback_md,
-                     grpc_millis* server_pushback_ms);
+                     absl::optional<grpc_millis> server_pushback_ms);
 
     // Abandons the call attempt.  Unrefs any deferred batches.
     void Abandon();
@@ -420,7 +416,6 @@ class RetryFilter::CallData {
     // BatchData.batch.payload points to this.
     grpc_transport_stream_op_batch_payload batch_payload_;
     // For send_initial_metadata.
-    grpc_linked_mdelem retry_attempts_metadata_;
     grpc_metadata_batch send_initial_metadata_{calld_->arena_};
     // For send_message.
     // TODO(roth): Restructure this to eliminate use of ManualConstructor.
@@ -509,8 +504,8 @@ class RetryFilter::CallData {
   void RetryCommit(CallAttempt* call_attempt);
 
   // Starts a timer to retry after appropriate back-off.
-  // If server_pushback_ms is -1, retry_backoff_ is used.
-  void StartRetryTimer(grpc_millis server_pushback_ms);
+  // If server_pushback_ms is nullopt, retry_backoff_ is used.
+  void StartRetryTimer(absl::optional<grpc_millis> server_pushback_ms);
 
   static void OnRetryTimer(void* arg, grpc_error_handle error);
   static void OnRetryTimerLocked(void* arg, grpc_error_handle error);
@@ -1065,7 +1060,7 @@ void RetryFilter::CallData::CallAttempt::CancelFromSurface(
 
 bool RetryFilter::CallData::CallAttempt::ShouldRetry(
     absl::optional<grpc_status_code> status, bool is_lb_drop,
-    grpc_mdelem* server_pushback_md, grpc_millis* server_pushback_ms) {
+    absl::optional<grpc_millis> server_pushback_ms) {
   // LB drops always inhibit retries.
   if (is_lb_drop) return false;
   // TODO(roth): Handle transparent retries here.
@@ -1131,10 +1126,8 @@ bool RetryFilter::CallData::CallAttempt::ShouldRetry(
     return false;
   }
   // Check server push-back.
-  if (server_pushback_md != nullptr) {
-    // If the value is "-1" or any other unparseable string, we do not retry.
-    uint32_t ms;
-    if (!grpc_parse_slice_to_uint32(GRPC_MDVALUE(*server_pushback_md), &ms)) {
+  if (server_pushback_ms.has_value()) {
+    if (*server_pushback_ms < 0) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
         gpr_log(GPR_INFO,
                 "chand=%p calld=%p attempt=%p: not retrying due to server "
@@ -1146,10 +1139,10 @@ bool RetryFilter::CallData::CallAttempt::ShouldRetry(
       if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
         gpr_log(
             GPR_INFO,
-            "chand=%p calld=%p attempt=%p: server push-back: retry in %u ms",
-            calld_->chand_, calld_, this, ms);
+            "chand=%p calld=%p attempt=%p: server push-back: retry in %" PRIu64
+            " ms",
+            calld_->chand_, calld_, this, *server_pushback_ms);
       }
-      *server_pushback_ms = static_cast<grpc_millis>(ms);
     }
   }
   // Check with call dispatch controller.
@@ -1236,11 +1229,11 @@ void RetryFilter::CallData::CallAttempt::OnPerAttemptRecvTimerLocked(
     // Check whether we should retry.
     if (call_attempt->ShouldRetry(
             /*status=*/absl::nullopt, /*is_lb_drop=*/false,
-            /*server_pushback_md=*/nullptr, /*server_pushback_ms=*/nullptr)) {
+            /*server_pushback_ms=*/absl::nullopt)) {
       // Mark current attempt as abandoned.
       call_attempt->Abandon();
       // We are retrying.  Start backoff timer.
-      calld->StartRetryTimer(/*server_pushback_ms=*/-1);
+      calld->StartRetryTimer(/*server_pushback_ms=*/absl::nullopt);
     } else {
       // Not retrying, so commit the call.
       calld->RetryCommit(call_attempt);
@@ -1534,11 +1527,12 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvMessageReady(
 
 namespace {
 
-// Sets *status, *server_pushback_md, and *is_lb_drop based on md_batch
+// Sets *status, *server_pushback_ms, and *is_lb_drop based on md_batch
 // and error.
 void GetCallStatus(grpc_millis deadline, grpc_metadata_batch* md_batch,
                    grpc_error_handle error, grpc_status_code* status,
-                   grpc_mdelem** server_pushback_md, bool* is_lb_drop) {
+                   absl::optional<grpc_millis>* server_pushback_ms,
+                   bool* is_lb_drop) {
   if (error != GRPC_ERROR_NONE) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
     intptr_t value = 0;
@@ -1547,13 +1541,8 @@ void GetCallStatus(grpc_millis deadline, grpc_metadata_batch* md_batch,
       *is_lb_drop = true;
     }
   } else {
-    GPR_ASSERT(md_batch->legacy_index()->named.grpc_status != nullptr);
-    *status = grpc_get_status_code_from_metadata(
-        md_batch->legacy_index()->named.grpc_status->md);
-    if (md_batch->legacy_index()->named.grpc_retry_pushback_ms != nullptr) {
-      *server_pushback_md =
-          &md_batch->legacy_index()->named.grpc_retry_pushback_ms->md;
-    }
+    *status = *md_batch->get(GrpcStatusMetadata());
+    *server_pushback_ms = md_batch->get(GrpcRetryPushbackMsMetadata());
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -1685,12 +1674,12 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvTrailingMetadataReady(
   call_attempt->MaybeCancelPerAttemptRecvTimer();
   // Get the call's status and check for server pushback metadata.
   grpc_status_code status = GRPC_STATUS_OK;
-  grpc_mdelem* server_pushback_md = nullptr;
+  absl::optional<grpc_millis> server_pushback_ms;
   grpc_metadata_batch* md_batch =
       batch_data->batch_.payload->recv_trailing_metadata.recv_trailing_metadata;
   bool is_lb_drop = false;
   GetCallStatus(calld->deadline_, md_batch, GRPC_ERROR_REF(error), &status,
-                &server_pushback_md, &is_lb_drop);
+                &server_pushback_ms, &is_lb_drop);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(
         GPR_INFO,
@@ -1699,9 +1688,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvTrailingMetadataReady(
         is_lb_drop);
   }
   // Check if we should retry.
-  grpc_millis server_pushback_ms = -1;
-  if (call_attempt->ShouldRetry(status, is_lb_drop, server_pushback_md,
-                                &server_pushback_ms)) {
+  if (call_attempt->ShouldRetry(status, is_lb_drop, server_pushback_ms)) {
     // Start retry timer.
     calld->StartRetryTimer(server_pushback_ms);
     // Cancel call attempt.
@@ -1893,35 +1880,19 @@ void RetryFilter::CallData::CallAttempt::BatchData::OnCompleteForCancelOp(
 void RetryFilter::CallData::CallAttempt::BatchData::
     AddRetriableSendInitialMetadataOp() {
   auto* calld = call_attempt_->calld_;
-  // Maps the number of retries to the corresponding metadata value slice.
-  const grpc_slice* retry_count_strings[] = {&GRPC_MDSTR_1, &GRPC_MDSTR_2,
-                                             &GRPC_MDSTR_3, &GRPC_MDSTR_4};
   // We need to make a copy of the metadata batch for each attempt, since
   // the filters in the subchannel stack may modify this batch, and we don't
   // want those modifications to be passed forward to subsequent attempts.
   //
   // If we've already completed one or more attempts, add the
   // grpc-retry-attempts header.
-  grpc_metadata_batch_copy(&calld->send_initial_metadata_,
-                           &call_attempt_->send_initial_metadata_);
-  if (GPR_UNLIKELY(call_attempt_->send_initial_metadata_.legacy_index()
-                       ->named.grpc_previous_rpc_attempts != nullptr)) {
-    call_attempt_->send_initial_metadata_.Remove(
-        GRPC_BATCH_GRPC_PREVIOUS_RPC_ATTEMPTS);
-  }
+  call_attempt_->send_initial_metadata_ = calld->send_initial_metadata_.Copy();
   if (GPR_UNLIKELY(calld->num_attempts_completed_ > 0)) {
-    grpc_mdelem retry_md = grpc_mdelem_create(
-        GRPC_MDSTR_GRPC_PREVIOUS_RPC_ATTEMPTS,
-        *retry_count_strings[calld->num_attempts_completed_ - 1], nullptr);
-    grpc_error_handle error = grpc_metadata_batch_add_tail(
-        &call_attempt_->send_initial_metadata_,
-        &call_attempt_->retry_attempts_metadata_, retry_md,
-        GRPC_BATCH_GRPC_PREVIOUS_RPC_ATTEMPTS);
-    if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
-      gpr_log(GPR_ERROR, "error adding retry metadata: %s",
-              grpc_error_std_string(error).c_str());
-      GPR_ASSERT(false);
-    }
+    call_attempt_->send_initial_metadata_.Set(GrpcPreviousRpcAttemptsMetadata(),
+                                              calld->num_attempts_completed_);
+  } else {
+    call_attempt_->send_initial_metadata_.Remove(
+        GrpcPreviousRpcAttemptsMetadata());
   }
   call_attempt_->started_send_initial_metadata_ = true;
   batch_.send_initial_metadata = true;
@@ -1958,8 +1929,8 @@ void RetryFilter::CallData::CallAttempt::BatchData::
   // We need to make a copy of the metadata batch for each attempt, since
   // the filters in the subchannel stack may modify this batch, and we don't
   // want those modifications to be passed forward to subsequent attempts.
-  grpc_metadata_batch_copy(&calld->send_trailing_metadata_,
-                           &call_attempt_->send_trailing_metadata_);
+  call_attempt_->send_trailing_metadata_ =
+      calld->send_trailing_metadata_.Copy();
   call_attempt_->started_send_trailing_metadata_ = true;
   batch_.send_trailing_metadata = true;
   batch_.payload->send_trailing_metadata.send_trailing_metadata =
@@ -2274,7 +2245,7 @@ void RetryFilter::CallData::MaybeCacheSendOpsForBatch(PendingBatch* pending) {
     seen_send_initial_metadata_ = true;
     grpc_metadata_batch* send_initial_metadata =
         batch->payload->send_initial_metadata.send_initial_metadata;
-    grpc_metadata_batch_copy(send_initial_metadata, &send_initial_metadata_);
+    send_initial_metadata_ = send_initial_metadata->Copy();
     send_initial_metadata_flags_ =
         batch->payload->send_initial_metadata.send_initial_metadata_flags;
     peer_string_ = batch->payload->send_initial_metadata.peer_string;
@@ -2290,7 +2261,7 @@ void RetryFilter::CallData::MaybeCacheSendOpsForBatch(PendingBatch* pending) {
     seen_send_trailing_metadata_ = true;
     grpc_metadata_batch* send_trailing_metadata =
         batch->payload->send_trailing_metadata.send_trailing_metadata;
-    grpc_metadata_batch_copy(send_trailing_metadata, &send_trailing_metadata_);
+    send_trailing_metadata_ = send_trailing_metadata->Copy();
   }
 }
 
@@ -2512,13 +2483,15 @@ void RetryFilter::CallData::RetryCommit(CallAttempt* call_attempt) {
   }
 }
 
-void RetryFilter::CallData::StartRetryTimer(grpc_millis server_pushback_ms) {
+void RetryFilter::CallData::StartRetryTimer(
+    absl::optional<grpc_millis> server_pushback_ms) {
   // Reset call attempt.
   call_attempt_.reset(DEBUG_LOCATION, "StartRetryTimer");
   // Compute backoff delay.
   grpc_millis next_attempt_time;
-  if (server_pushback_ms >= 0) {
-    next_attempt_time = ExecCtx::Get()->Now() + server_pushback_ms;
+  if (server_pushback_ms.has_value()) {
+    GPR_ASSERT(*server_pushback_ms >= 0);
+    next_attempt_time = ExecCtx::Get()->Now() + *server_pushback_ms;
     retry_backoff_.Reset();
   } else {
     next_attempt_time = retry_backoff_.NextAttemptTime();

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

@@ -31,12 +31,12 @@
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/json/json_util.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.

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

@@ -22,9 +22,9 @@
 #include <memory>
 
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
-#include "src/core/ext/service_config/service_config_parser.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
+#include "src/core/lib/service_config/service_config_parser.h"
 
 namespace grpc_core {
 namespace internal {

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

@@ -19,11 +19,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/service_config/service_config_call_data.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
 
 namespace grpc_core {
 

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

@@ -26,6 +26,7 @@
 
 #include "absl/strings/str_format.h"
 
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -50,7 +51,6 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/status_metadata.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // Strong and weak refs.
@@ -141,14 +141,14 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
-      callstk,           /* call_stack */
-      nullptr,           /* server_transport_data */
-      args.context,      /* context */
-      args.path,         /* path */
-      args.start_time,   /* start_time */
-      args.deadline,     /* deadline */
-      args.arena,        /* arena */
-      args.call_combiner /* call_combiner */
+      callstk,             /* call_stack */
+      nullptr,             /* server_transport_data */
+      args.context,        /* context */
+      args.path.c_slice(), /* path */
+      args.start_time,     /* start_time */
+      args.deadline,       /* deadline */
+      args.arena,          /* arena */
+      args.call_combiner   /* call_combiner */
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
@@ -252,12 +252,7 @@ void GetCallStatus(grpc_status_code* status, grpc_millis deadline,
   if (error != GRPC_ERROR_NONE) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
   } else {
-    if (md_batch->legacy_index()->named.grpc_status != nullptr) {
-      *status = grpc_get_status_code_from_metadata(
-          md_batch->legacy_index()->named.grpc_status->md);
-    } else {
-      *status = GRPC_STATUS_UNKNOWN;
-    }
+    *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -969,7 +964,8 @@ void ConnectionDestroy(void* arg, grpc_error_handle /*error*/) {
 
 bool Subchannel::PublishTransportLocked() {
   // Construct channel stack.
-  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
+  grpc_channel_stack_builder* builder =
+      grpc_channel_stack_builder_create("subchannel");
   grpc_channel_stack_builder_set_channel_arguments(
       builder, connecting_result_.channel_args);
   grpc_channel_stack_builder_set_transport(builder,

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

@@ -27,15 +27,14 @@
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata.h"
 
 namespace grpc_core {
 
@@ -75,7 +74,7 @@ class SubchannelCall {
   struct Args {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     grpc_polling_entity* pollent;
-    grpc_slice path;
+    Slice path;
     gpr_cycle_counter start_time;
     grpc_millis deadline;
     Arena* arena;

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

@@ -22,16 +22,17 @@
 
 #include "absl/strings/numbers.h"
 
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
-#include "src/core/ext/service_config/service_config_call_data.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/transport/status_conversion.h"
 
 namespace grpc_core {
@@ -45,31 +46,11 @@ static_assert(
     std::is_trivially_destructible<std::atomic<uint32_t>>::value,
     "the active fault counter needs to have a trivially destructible type");
 
-inline int GetMetadatumValueInt(grpc_mdelem md) {
-  int res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
-    return res;
-  } else {
-    return -1;
-  }
-}
-
-inline uint32_t GetMetadatumValueUnsignedInt(grpc_mdelem md) {
-  uint32_t res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
-    return res;
-  } else {
-    return -1;
-  }
-}
-
-inline int64_t GetMetadatumValueInt64(grpc_mdelem md) {
-  int64_t res;
-  if (absl::SimpleAtoi(StringViewFromSlice(GRPC_MDVALUE(md)), &res)) {
-    return res;
-  } else {
-    return -1;
-  }
+template <typename T>
+auto AsInt(absl::string_view s) -> absl::optional<T> {
+  T x;
+  if (absl::SimpleAtoi(s, &x)) return x;
+  return absl::nullopt;
 }
 
 inline bool UnderFraction(const uint32_t numerator,
@@ -346,41 +327,49 @@ void CallData::DecideWhetherToInjectFaults(
                 *fi_policy_);
       }
     };
-    initial_metadata->ForEach([&](grpc_mdelem md) {
-      absl::string_view key = StringViewFromSlice(GRPC_MDKEY(md));
-      // Only perform string comparison if:
-      //   1. Needs to check this header;
-      //   2. The value is not been filled before.
-      if (!fi_policy_->abort_code_header.empty() &&
-          (copied_policy == nullptr ||
-           copied_policy->abort_code == GRPC_STATUS_OK) &&
-          key == fi_policy_->abort_code_header) {
+    std::string buffer;
+    if (!fi_policy_->abort_code_header.empty() &&
+        (copied_policy == nullptr ||
+         copied_policy->abort_code == GRPC_STATUS_OK)) {
+      auto value = initial_metadata->GetStringValue(
+          fi_policy_->abort_code_header, &buffer);
+      if (value.has_value()) {
         maybe_copy_policy_func();
-        grpc_status_code_from_int(GetMetadatumValueInt(md),
-                                  &copied_policy->abort_code);
+        grpc_status_code_from_int(
+            AsInt<int>(*value).value_or(GRPC_STATUS_UNKNOWN),
+            &copied_policy->abort_code);
       }
-      if (!fi_policy_->abort_percentage_header.empty() &&
-          key == fi_policy_->abort_percentage_header) {
+    }
+    if (!fi_policy_->abort_percentage_header.empty()) {
+      auto value = initial_metadata->GetStringValue(
+          fi_policy_->abort_percentage_header, &buffer);
+      if (value.has_value()) {
         maybe_copy_policy_func();
         copied_policy->abort_percentage_numerator =
-            std::min(GetMetadatumValueUnsignedInt(md),
+            std::min(AsInt<uint32_t>(*value).value_or(-1),
                      fi_policy_->abort_percentage_numerator);
       }
-      if (!fi_policy_->delay_header.empty() &&
-          (copied_policy == nullptr || copied_policy->delay == 0) &&
-          key == fi_policy_->delay_header) {
+    }
+    if (!fi_policy_->delay_header.empty() &&
+        (copied_policy == nullptr || copied_policy->delay == 0)) {
+      auto value =
+          initial_metadata->GetStringValue(fi_policy_->delay_header, &buffer);
+      if (value.has_value()) {
         maybe_copy_policy_func();
         copied_policy->delay = static_cast<grpc_millis>(
-            std::max(GetMetadatumValueInt64(md), int64_t(0)));
+            std::max(AsInt<int64_t>(*value).value_or(0), int64_t(0)));
       }
-      if (!fi_policy_->delay_percentage_header.empty() &&
-          key == fi_policy_->delay_percentage_header) {
+    }
+    if (!fi_policy_->delay_percentage_header.empty()) {
+      auto value = initial_metadata->GetStringValue(
+          fi_policy_->delay_percentage_header, &buffer);
+      if (value.has_value()) {
         maybe_copy_policy_func();
         copied_policy->delay_percentage_numerator =
-            std::min(GetMetadatumValueUnsignedInt(md),
+            std::min(AsInt<uint32_t>(*value).value_or(-1),
                      fi_policy_->delay_percentage_numerator);
       }
-    });
+    }
     if (copied_policy != nullptr) fi_policy_ = copied_policy;
   }
   // Roll the dice

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

@@ -122,14 +122,12 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
       }
     }
     // Parse max_faults
-    if (ParseJsonObjectField(json_object, "maxFaults",
-                             &fault_injection_policy.max_faults,
-                             &sub_error_list, false)) {
-      if (fault_injection_policy.max_faults < 0) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxFaults error:should be zero or positive"));
-      }
-    }
+    static_assert(
+        std::is_unsigned<decltype(fault_injection_policy.max_faults)>::value,
+        "maxFaults should be unsigned");
+    ParseJsonObjectField(json_object, "maxFaults",
+                         &fault_injection_policy.max_faults, &sub_error_list,
+                         false);
     if (!sub_error_list.empty()) {
       error_list->push_back(GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
           absl::StrCat("failed to parse faultInjectionPolicy index ", i),

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

@@ -21,8 +21,8 @@
 
 #include <vector>
 
-#include "src/core/ext/service_config/service_config_parser.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 
 namespace grpc_core {