grpc 1.84.1 → 1.85.0.pre1

data/include/grpc/event_engine/memory_allocator.h

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace grpc_event_engine {

data/include/grpc/grpc.h

@@ -320,6 +320,9 @@ GRPCAPI grpc_channel* grpc_lame_client_channel_create(
 /** Close and destroy a grpc channel */
 GRPCAPI void grpc_channel_destroy(grpc_channel* channel);
 
+/** Returns a vtable for storing grpc_channel_args in a channel arg. */
+GRPCAPI const grpc_arg_pointer_vtable* grpc_channel_args_arg_vtable(void);
+
 /** Error handling for grpc_call
    Most grpc_call functions return a grpc_error. If the error is not GRPC_OK
    then the operation failed due to some unsatisfied precondition.

data/include/grpc/grpc_security_constants.h

@@ -159,6 +159,8 @@ typedef enum {
   GRPC_TLS_GROUP_X25519_MLKEM768,
   /** secp384r1 ECDH key exchange. */
   GRPC_TLS_GROUP_SECP384R1,
+  /** MLKEM1024 key exchange. Post-quantum cryptography. */
+  GRPC_TLS_GROUP_MLKEM1024,
 } grpc_tls_key_exchange_group;
 
 #ifdef __cplusplus

data/include/grpc/impl/channel_arg_names.h

@@ -136,6 +136,10 @@
  */
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
   "grpc.server.max_pending_requests_hard_limit"
+/** A pointer argument key. The value is a pointer to a grpc_channel_args
+ *  struct containing the subset of options for child channels.
+ */
+#define GRPC_ARG_CHILD_CHANNEL_ARGS "grpc.child_channel.args"
 /** Channel arg to override the http2 :scheme header. String valued. */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a data/header

data/src/core/call/call_filters.h

@@ -888,7 +888,7 @@ template <typename FilterType, typename T, typename R,
           R (FilterType::Call::*impl)(typename T::element_type&)>
 struct AddOpImpl<
     FilterType, T, R (FilterType::Call::*)(typename T::element_type&), impl,
-    absl::enable_if_t<std::is_same<absl::Status, PromiseResult<R>>::value>> {
+    std::enable_if_t<std::is_same<absl::Status, PromiseResult<R>>::value>> {
   static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     class Promise {
      public:
@@ -940,8 +940,8 @@ template <typename FilterType, typename T, typename R,
 struct AddOpImpl<
     FilterType, T,
     R (FilterType::Call::*)(typename T::element_type&, FilterType*), impl,
-    absl::enable_if_t<!std::is_same<R, absl::Status>::value &&
-                      std::is_same<absl::Status, PromiseResult<R>>::value>> {
+    std::enable_if_t<!std::is_same<R, absl::Status>::value &&
+                     std::is_same<absl::Status, PromiseResult<R>>::value>> {
   static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
     class Promise {
      public:
@@ -993,8 +993,8 @@ struct AddOpImpl<
 template <typename FilterType, typename T, typename R,
           R (FilterType::Call::*impl)(T, FilterType*)>
 struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
-                 absl::enable_if_t<std::is_same<absl::StatusOr<T>,
-                                                PromiseResult<R>>::value>> {
+                 std::enable_if_t<std::is_same<absl::StatusOr<T>,
+                                               PromiseResult<R>>::value>> {
   static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
 #if defined(__GNUC__) && __GNUC__ == 9
     // Workaround for a bug in GNU C++ 9 compilers that fail to compile this
@@ -1198,7 +1198,7 @@ struct StackData {
   // we have exactly one caller for is warranted for a more thorough testing
   // story.
   template <typename FilterType>
-  absl::enable_if_t<!std::is_empty<typename FilterType::Call>::value, size_t>
+  std::enable_if_t<!std::is_empty<typename FilterType::Call>::value, size_t>
   AddFilterConstructor(FilterType* channel_data) {
     const size_t alignment = alignof(typename FilterType::Call);
     call_data_alignment = std::max(call_data_alignment, alignment);
@@ -1219,7 +1219,7 @@ struct StackData {
   }
 
   template <typename FilterType>
-  absl::enable_if_t<
+  std::enable_if_t<
       std::is_empty<typename FilterType::Call>::value &&
           !std::is_trivially_constructible<typename FilterType::Call>::value,
       size_t>
@@ -1238,7 +1238,7 @@ struct StackData {
   }
 
   template <typename FilterType>
-  absl::enable_if_t<
+  std::enable_if_t<
       std::is_empty<typename FilterType::Call>::value &&
           std::is_trivially_constructible<typename FilterType::Call>::value,
       size_t>
@@ -1249,7 +1249,7 @@ struct StackData {
   }
 
   template <typename FilterType>
-  absl::enable_if_t<
+  std::enable_if_t<
       !std::is_trivially_destructible<typename FilterType::Call>::value>
   AddFilterDestructor(size_t call_offset) {
     filter_destructor.push_back(FilterDestructor{
@@ -1261,7 +1261,7 @@ struct StackData {
   }
 
   template <typename FilterType>
-  absl::enable_if_t<
+  std::enable_if_t<
       std::is_trivially_destructible<typename FilterType::Call>::value>
   AddFilterDestructor(size_t) {}
 

data/src/core/{lib/security/authorization → call}/evaluate_args.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/security/authorization/evaluate_args.h"
+#include "src/core/call/evaluate_args.h"
 
 #include <grpc/grpc_security_constants.h>
 #include <grpc/support/port_platform.h>
@@ -78,6 +78,10 @@ EvaluateArgs::PerChannelArgs::PerChannelArgs(grpc_auth_context* auth_context,
         GetAuthPropertyValue(auth_context, GRPC_X509_CN_PROPERTY_NAME);
     subject =
         GetAuthPropertyValue(auth_context, GRPC_X509_SUBJECT_PROPERTY_NAME);
+    requested_server_name = GetAuthPropertyValue(
+        auth_context, GRPC_SSL_REQUESTED_SERVER_NAME_PROPERTY_NAME);
+    tls_version =
+        GetAuthPropertyValue(auth_context, GRPC_SSL_TLS_VERSION_PROPERTY_NAME);
   }
   local_address = ParseEndpointUri(
       args.GetString(GRPC_ARG_ENDPOINT_LOCAL_ADDRESS).value_or(""));
@@ -100,6 +104,9 @@ absl::string_view EvaluateArgs::GetAuthority() const {
   if (metadata_ != nullptr) {
     if (auto* authority_md = metadata_->get_pointer(HttpAuthorityMetadata())) {
       authority = authority_md->as_string_view();
+    } else if (auto* host_md = metadata_->get_pointer(HostMetadata())) {
+      // Fall back to the legacy host header.
+      authority = host_md->as_string_view();
     }
   }
   return authority;
@@ -214,4 +221,18 @@ absl::string_view EvaluateArgs::GetSubject() const {
   return channel_args_->subject;
 }
 
+absl::string_view EvaluateArgs::GetRequestedServerName() const {
+  if (channel_args_ == nullptr) {
+    return "";
+  }
+  return channel_args_->requested_server_name;
+}
+
+absl::string_view EvaluateArgs::GetTlsVersion() const {
+  if (channel_args_ == nullptr) {
+    return "";
+  }
+  return channel_args_->tls_version;
+}
+
 }  // namespace grpc_core

data/src/core/{lib/security/authorization → call}/evaluate_args.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
-#define GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
+#ifndef GRPC_SRC_CORE_CALL_EVALUATE_ARGS_H
+#define GRPC_SRC_CORE_CALL_EVALUATE_ARGS_H
 
 #include <grpc/grpc_security.h>
 #include <grpc/support/port_platform.h>
@@ -50,14 +50,19 @@ class EvaluateArgs final {
     std::vector<absl::string_view> dns_sans;
     absl::string_view common_name;
     absl::string_view subject;
+    absl::string_view requested_server_name;
+    absl::string_view tls_version;
     Address local_address;
     Address peer_address;
   };
 
-  EvaluateArgs(grpc_metadata_batch* metadata, PerChannelArgs* channel_args)
+  EvaluateArgs(grpc_metadata_batch* metadata,
+               const PerChannelArgs* channel_args)
       : metadata_(metadata), channel_args_(channel_args) {}
 
   absl::string_view GetPath() const;
+  // Returns the value of the :authority header, falling back to the legacy
+  // host header if :authority is not present.
   absl::string_view GetAuthority() const;
   absl::string_view GetMethod() const;
   // Returns metadata value(s) for the specified key.
@@ -82,12 +87,21 @@ class EvaluateArgs final {
   std::vector<absl::string_view> GetDnsSans() const;
   absl::string_view GetCommonName() const;
   absl::string_view GetSubject() const;
+  absl::string_view GetRequestedServerName() const;
+  absl::string_view GetTlsVersion() const;
+
+  // Iterates over all metadata entries, invoking encoder->Encode() for each
+  // one.  See grpc_metadata_batch::Encode() for details.
+  template <typename Encoder>
+  void EncodeHeaders(Encoder* encoder) const {
+    if (metadata_ != nullptr) metadata_->Encode(encoder);
+  }
 
  private:
   grpc_metadata_batch* metadata_;
-  PerChannelArgs* channel_args_;
+  const PerChannelArgs* channel_args_;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
+#endif  // GRPC_SRC_CORE_CALL_EVALUATE_ARGS_H

data/src/core/call/filter_fusion.h

@@ -222,7 +222,7 @@ struct StatusType {
 
 template <typename T>
 struct StatusType<
-    T, absl::enable_if_t<
+    T, std::enable_if_t<
            std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
                !std::is_same<T, ServerMetadataHandle>::value &&
                !TakeValueExists<T>::value,
@@ -256,7 +256,7 @@ struct StatusOrType {
 template <typename T, typename U>
 struct StatusOrType<
     T, U,
-    absl::enable_if_t<
+    std::enable_if_t<
         std::is_same<decltype(IsStatusOk(std::declval<T>())), bool>::value &&
             TakeValueExists<T>::value && HasStatusMethod<T>::value &&
             std::is_same<decltype(TakeValue(std::declval<T>())), U>::value,
@@ -271,8 +271,8 @@ template <typename T, typename A, typename R, typename Call,
           R (Call::*method)(A)>
 class AdaptMethod<
     T, R (Call::*)(A), method,
-    absl::enable_if_t<StatusType<R>::value && IsSameExcludingCVRef<T, A>,
-                      void>> {
+    std::enable_if_t<StatusType<R>::value && IsSameExcludingCVRef<T, A>,
+                     void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> x) {
@@ -290,7 +290,7 @@ class AdaptMethod<
 
 template <typename T, typename R, typename Call, R (Call::*method)()>
 class AdaptMethod<T, R (Call::*)(), method,
-                  absl::enable_if_t<StatusType<R>::value, void>> {
+                  std::enable_if_t<StatusType<R>::value, void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> x) {
@@ -310,8 +310,8 @@ template <typename T, typename A, typename R, typename Call, typename Derived,
           R (Call::*method)(A, Derived*)>
 class AdaptMethod<
     T, R (Call::*)(A, Derived*), method,
-    absl::enable_if_t<StatusType<R>::value && IsSameExcludingCVRef<T, A>,
-                      void>> {
+    std::enable_if_t<StatusType<R>::value && IsSameExcludingCVRef<T, A>,
+                     void>> {
  public:
   explicit AdaptMethod(Call* call, Derived* filter)
       : call_(call), filter_(filter) {}
@@ -335,8 +335,8 @@ template <typename T, typename A, typename R, typename Call,
           R (Call::*method)(A)>
 class AdaptMethod<
     T, R (Call::*)(A), method,
-    absl::enable_if_t<StatusOrType<R, T>::value && IsSameExcludingCVRef<T, A>,
-                      void>> {
+    std::enable_if_t<StatusOrType<R, T>::value && IsSameExcludingCVRef<T, A>,
+                     void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> x) {
@@ -355,7 +355,7 @@ class AdaptMethod<
 
 template <typename T, typename R, typename Call, R (Call::*method)()>
 class AdaptMethod<T, R (Call::*)(), method,
-                  absl::enable_if_t<StatusOrType<R, T>::value, void>> {
+                  std::enable_if_t<StatusOrType<R, T>::value, void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> /*x*/) {
@@ -376,8 +376,8 @@ template <typename T, typename A, typename R, typename Call, typename Derived,
           R (Call::*method)(A, Derived*)>
 class AdaptMethod<
     T, R (Call::*)(A, Derived*), method,
-    absl::enable_if_t<StatusOrType<R, T>::value && IsSameExcludingCVRef<T, A>,
-                      void>> {
+    std::enable_if_t<StatusOrType<R, T>::value && IsSameExcludingCVRef<T, A>,
+                     void>> {
  public:
   using UnwrappedType = decltype(TakeValue(std::declval<R>()));
   static_assert(std::is_same<UnwrappedType, T>::value);
@@ -402,7 +402,7 @@ class AdaptMethod<
 // return a StatusOr<Hdl<T>> type as output
 template <typename T, typename R, typename Call, R (Call::*method)(Hdl<T>)>
 class AdaptMethod<T, R (Call::*)(Hdl<T>), method,
-                  absl::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
+                  std::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> x) {
@@ -421,7 +421,7 @@ class AdaptMethod<T, R (Call::*)(Hdl<T>), method,
 
 template <typename T, typename R, typename Call, R (Call::*method)()>
 class AdaptMethod<T, R (Call::*)(), method,
-                  absl::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
+                  std::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
  public:
   explicit AdaptMethod(Call* call, void* /*filter*/ = nullptr) : call_(call) {}
   auto operator()(Hdl<T> /*x*/) {
@@ -441,7 +441,7 @@ class AdaptMethod<T, R (Call::*)(), method,
 template <typename T, typename R, typename Call, typename Derived,
           R (Call::*method)(Hdl<T>, Derived*)>
 class AdaptMethod<T, R (Call::*)(Hdl<T>, Derived*), method,
-                  absl::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
+                  std::enable_if_t<StatusOrType<R, Hdl<T>>::value, void>> {
  public:
   explicit AdaptMethod(Call* call, Derived* filter)
       : call_(call), filter_(filter) {}

data/src/core/call/interception_chain.h

@@ -193,7 +193,7 @@ class InterceptionChainBuilder final {
   // Call class must be one compatible with the filters described in
   // call_filters.h.
   template <typename T>
-  absl::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
+  std::enable_if_t<sizeof(typename T::Call) != 0, InterceptionChainBuilder&>
   Add(RefCountedPtr<const FilterConfig> config) {
     if (!status_.ok()) return *this;
     auto filter = T::Create(
@@ -210,8 +210,8 @@ class InterceptionChainBuilder final {
 
   // Add a filter that is an interceptor - one that can hijack calls.
   template <typename T>
-  absl::enable_if_t<std::is_base_of<Interceptor, T>::value,
-                    InterceptionChainBuilder&>
+  std::enable_if_t<std::is_base_of<Interceptor, T>::value,
+                   InterceptionChainBuilder&>
   Add(RefCountedPtr<const FilterConfig> config) {
     AddInterceptor(T::Create(
         args_, {FilterInstanceId(FilterTypeId<T>()), std::move(config)}));

data/src/core/call/metadata_batch.cc

@@ -58,6 +58,7 @@ bool IsMetadataKeyAllowedInDebugOutput(absl::string_view key) {
   if (key == TeMetadata::key()) return true;
   if (key == UserAgentMetadata::key()) return true;
   if (key == W3CTraceParentMetadata::key()) return true;
+  if (key == XEnvoyAuthFailureModeAllowedMetadata::key()) return true;
   if (key == XEnvoyPeerMetadata::key()) return true;
   if (key == XForwardedForMetadata::key()) return true;
   if (key == XForwardedHostMetadata::key()) return true;

data/src/core/call/metadata_batch.h

@@ -342,6 +342,16 @@ struct XEnvoyPeerMetadata : public SimpleSliceBasedMetadata {
   static absl::string_view key() { return "x-envoy-peer-metadata"; }
 };
 
+// x-envoy-auth-failure-mode-allowed metadata trait for ext_authz failure mode
+// allow.
+struct XEnvoyAuthFailureModeAllowedMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kPublishToApp = true;
+  static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
+  using CompressionTraits = StableValueCompressor;
+  static absl::string_view key() { return "x-envoy-auth-failure-mode-allowed"; }
+};
+
 // x-forwarded-for metadata trait for HTTP connect.
 struct XForwardedForMetadata : public SimpleSliceBasedMetadata {
   static constexpr bool kPublishToApp = true;
@@ -722,7 +732,7 @@ template <typename MustBeVoid, typename... Traits>
 struct EncodableTraits;
 
 template <typename Trait, typename... Traits>
-struct EncodableTraits<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
+struct EncodableTraits<std::enable_if_t<IsEncodableTrait<Trait>::value, void>,
                        Trait, Traits...> {
   using List =
       typename EncodableTraits<void,
@@ -730,7 +740,7 @@ struct EncodableTraits<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
 };
 
 template <typename Trait, typename... Traits>
-struct EncodableTraits<absl::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
+struct EncodableTraits<std::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
                        Trait, Traits...> {
   using List = typename EncodableTraits<void, Traits...>::List;
 };
@@ -883,7 +893,7 @@ class GetStringValueHelper {
       : container_(container), backing_(backing) {}
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == false &&
           std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -894,7 +904,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == true &&
           std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -910,7 +920,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == true &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -927,7 +937,7 @@ class GetStringValueHelper {
   }
 
   template <typename Trait>
-  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+  GPR_ATTRIBUTE_NOINLINE std::enable_if_t<
       Trait::kRepeatable == false &&
           !std::is_same<Slice, typename Trait::ValueType>::value,
       std::optional<absl::string_view>>
@@ -1003,9 +1013,9 @@ template <typename Which, typename Ignored = void>
 struct Value;
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
-                                          IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == false &&
+                                         IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) : value(value) {}
   explicit Value(typename Which::ValueType&& value)
@@ -1034,9 +1044,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
-                                          !IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == false &&
+                                         !IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) : value(value) {}
   explicit Value(typename Which::ValueType&& value)
@@ -1063,9 +1073,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
-                                          IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == true &&
+                                         IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) {
     this->value.push_back(value);
@@ -1101,9 +1111,9 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
 };
 
 template <typename Which>
-struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
-                                          !IsEncodableTrait<Which>::value,
-                                      void>> {
+struct Value<Which, std::enable_if_t<Which::kRepeatable == true &&
+                                         !IsEncodableTrait<Which>::value,
+                                     void>> {
   Value() = default;
   explicit Value(const typename Which::ValueType& value) {
     this->value.push_back(value);
@@ -1199,13 +1209,13 @@ struct FilterWrapper {
   Filterer filter_fn;
 
   template <typename Which,
-            absl::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
+            std::enable_if_t<IsEncodableTrait<Which>::value, bool> = true>
   bool operator()(const Value<Which>& /*which*/) {
     return filter_fn(Which());
   }
 
   template <typename Which,
-            absl::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
+            std::enable_if_t<!IsEncodableTrait<Which>::value, bool> = true>
   bool operator()(const Value<Which>& /*which*/) {
     return true;
   }
@@ -1306,14 +1316,14 @@ struct StatefulCompressor<Factory> {};
 // Helper function for encoders
 // Given a metadata trait, convert the value to a slice.
 template <typename Which>
-absl::enable_if_t<std::is_same<typename Which::ValueType, Slice>::value,
-                  const Slice&>
+std::enable_if_t<std::is_same<typename Which::ValueType, Slice>::value,
+                 const Slice&>
 MetadataValueAsSlice(const Slice& slice) {
   return slice;
 }
 
 template <typename Which>
-absl::enable_if_t<!std::is_same<typename Which::ValueType, Slice>::value, Slice>
+std::enable_if_t<!std::is_same<typename Which::ValueType, Slice>::value, Slice>
 MetadataValueAsSlice(typename Which::ValueType value) {
   return Slice(Which::Encode(value));
 }
@@ -1580,13 +1590,13 @@ class MetadataMap {
   // Set the value of some known metadata.
   // Returns a pointer to the new value.
   template <typename Which, typename... Args>
-  absl::enable_if_t<Which::kRepeatable == false, void> Set(Which,
-                                                           Args&&... args) {
+  std::enable_if_t<Which::kRepeatable == false, void> Set(Which,
+                                                          Args&&... args) {
     table_.template set<Value<Which>>(std::forward<Args>(args)...);
   }
   template <typename Which, typename... Args>
-  absl::enable_if_t<Which::kRepeatable == true, void> Set(Which,
-                                                          Args&&... args) {
+  std::enable_if_t<Which::kRepeatable == true, void> Set(Which,
+                                                         Args&&... args) {
     GetOrCreatePointer(Which())->emplace_back(std::forward<Args>(args)...);
   }
 
@@ -1618,8 +1628,8 @@ class MetadataMap {
   //  auto value = m.get(T());
   //  m.Remove(T());
   template <typename Which>
-  absl::enable_if_t<Which::kRepeatable == false,
-                    std::optional<typename Which::ValueType>>
+  std::enable_if_t<Which::kRepeatable == false,
+                   std::optional<typename Which::ValueType>>
   Take(Which which) {
     if (auto* p = get_pointer(which)) {
       std::optional<typename Which::ValueType> value(std::move(*p));
@@ -1632,8 +1642,8 @@ class MetadataMap {
   // Extract repeated known metadata.
   // Returns an empty vector if the metadata was not present.
   template <typename Which>
-  absl::enable_if_t<Which::kRepeatable == true,
-                    typename metadata_detail::Value<Which>::StorageType>
+  std::enable_if_t<Which::kRepeatable == true,
+                   typename metadata_detail::Value<Which>::StorageType>
   Take(Which which) {
     if (auto* p = get_pointer(which)) {
       typename Value<Which>::StorageType value = std::move(*p);
@@ -1757,8 +1767,10 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
-    grpc_core::XEnvoyPeerMetadata, grpc_core::XForwardedForMetadata,
-    grpc_core::XForwardedHostMetadata, grpc_core::W3CTraceParentMetadata,
+    grpc_core::XEnvoyPeerMetadata,
+    grpc_core::XEnvoyAuthFailureModeAllowedMetadata,
+    grpc_core::XForwardedForMetadata, grpc_core::XForwardedHostMetadata,
+    grpc_core::W3CTraceParentMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::LbPolicyDrop,
     grpc_core::PeerString, grpc_core::GrpcStatusContext,

data/src/core/call/parsed_metadata.h

@@ -120,8 +120,8 @@ class ParsedMetadata {
   template <typename Which>
   ParsedMetadata(
       Which,
-      absl::enable_if_t<metadata_detail::HasSimpleMemento<Which>::value,
-                        typename Which::MementoType>
+      std::enable_if_t<metadata_detail::HasSimpleMemento<Which>::value,
+                       typename Which::MementoType>
           value,
       uint32_t transport_size)
       : vtable_(ParsedMetadata::template TrivialTraitVTable<Which>()),
@@ -131,7 +131,7 @@ class ParsedMetadata {
   template <typename Which>
   ParsedMetadata(
       Which,
-      absl::enable_if_t<
+      std::enable_if_t<
           !metadata_detail::HasSimpleMemento<Which>::value &&
               !std::is_convertible<typename Which::MementoType, Slice>::value,
           typename Which::MementoType>

data/src/core/call/request_buffer.cc

@@ -28,7 +28,7 @@ RequestBuffer::RequestBuffer() : state_(absl::in_place_type_t<Buffering>()) {}
 
 ValueOrFailure<size_t> RequestBuffer::PushClientInitialMetadata(
     ClientMetadataHandle md) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   auto& buffering = std::get<Buffering>(state_);
   CHECK_EQ(buffering.initial_metadata.get(), nullptr);
@@ -40,7 +40,7 @@ ValueOrFailure<size_t> RequestBuffer::PushClientInitialMetadata(
 
 Poll<ValueOrFailure<size_t>> RequestBuffer::PollPushMessage(
     MessageHandle& message) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   size_t buffered = 0;
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
@@ -61,7 +61,7 @@ Poll<ValueOrFailure<size_t>> RequestBuffer::PollPushMessage(
 }
 
 StatusFlag RequestBuffer::FinishSends() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::get_if<Cancelled>(&state_)) return Failure{};
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
     Buffered buffered(std::move(buffering->initial_metadata),
@@ -77,14 +77,14 @@ StatusFlag RequestBuffer::FinishSends() {
 }
 
 void RequestBuffer::Cancel(absl::Status error) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (std::holds_alternative<Cancelled>(state_)) return;
   state_.emplace<Cancelled>(std::move(error));
   WakeupAsyncAllPullers();
 }
 
 void RequestBuffer::Commit(Reader* winner) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   CHECK_EQ(winner_, nullptr);
   winner_ = winner;
   if (auto* buffering = std::get_if<Buffering>(&state_)) {
@@ -111,7 +111,7 @@ void RequestBuffer::WakeupAsyncAllPullersExcept(Reader* except_reader) {
 
 Poll<ValueOrFailure<ClientMetadataHandle>>
 RequestBuffer::Reader::PollPullClientInitialMetadata() {
-  MutexLock lock(&buffer_->mu_);
+  MutexLock lock(buffer_->mu_);
   if (buffer_->winner_ != nullptr && buffer_->winner_ != this) {
     error_ = absl::CancelledError("Another call was chosen");
     return Failure{};

data/src/core/call/request_buffer.h

@@ -108,7 +108,7 @@ class RequestBuffer {
   void Commit(Reader* winner);
 
   bool committed() const {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     return winner_ != nullptr;
   }