grpc 1.45.0 → 1.46.2

data/src/core/lib/resource_quota/api.cc

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 
 namespace grpc_core {
 
@@ -30,30 +31,13 @@ ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
       ->Ref();
 }
 
-namespace {
-grpc_arg MakeArg(ResourceQuota* quota) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), quota,
-      grpc_resource_quota_arg_vtable());
-}
-
-const grpc_channel_args* EnsureResourceQuotaInChannelArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* existing =
-      grpc_channel_args_find(args, GRPC_ARG_RESOURCE_QUOTA);
-  if (existing != nullptr && existing->type == GRPC_ARG_POINTER &&
-      existing->value.pointer.p != nullptr) {
-    return grpc_channel_args_copy(args);
-  }
+ChannelArgs EnsureResourceQuotaInChannelArgs(ChannelArgs args) {
+  if (args.GetObject<ResourceQuota>() != nullptr) return args;
   // If there's no existing quota, add it to the default one - shared between
   // all channel args declared thusly. This prevents us from accidentally not
   // sharing subchannels due to their channel args not specifying a quota.
-  const char* remove[] = {GRPC_ARG_RESOURCE_QUOTA};
-  auto new_arg = MakeArg(ResourceQuota::Default().get());
-  return grpc_channel_args_copy_and_add_and_remove(args, remove, 1, &new_arg,
-                                                   1);
+  return args.SetObject(ResourceQuota::Default());
 }
-}  // namespace
 
 void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
   builder->channel_args_preconditioning()->RegisterStage(
@@ -63,16 +47,7 @@ void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
 }  // namespace grpc_core
 
 extern "C" const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable() {
-  static const grpc_arg_pointer_vtable vtable = {
-      // copy
-      [](void* p) -> void* {
-        return static_cast<grpc_core::ResourceQuota*>(p)->Ref().release();
-      },
-      // destroy
-      [](void* p) { static_cast<grpc_core::ResourceQuota*>(p)->Unref(); },
-      // compare
-      [](void* p, void* q) { return grpc_core::QsortCompare(p, q); }};
-  return &vtable;
+  return grpc_core::ChannelArgTypeTraits<grpc_core::ResourceQuota>::VTable();
 }
 
 extern "C" grpc_resource_quota* grpc_resource_quota_create(const char* name) {

data/src/core/lib/resource_quota/api.h

@@ -27,7 +27,7 @@ namespace grpc_core {
 
 // TODO(ctiller): This is a hack. We need to do real accounting instead of
 // hard coding.
-constexpr size_t kResourceQuotaChannelSize = 50 * 1024;
+constexpr size_t kResourceQuotaChannelSize = 34 * 1024;
 
 // Retrieve the resource quota from the channel args.
 // UB if not set.

data/src/core/lib/resource_quota/resource_quota.h

@@ -19,6 +19,7 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/thread_quota.h"
@@ -37,6 +38,8 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
   ResourceQuota(const ResourceQuota&) = delete;
   ResourceQuota& operator=(const ResourceQuota&) = delete;
 
+  static absl::string_view ChannelArgName() { return GRPC_ARG_RESOURCE_QUOTA; }
+
   MemoryQuotaRefPtr memory_quota() { return memory_quota_; }
 
   const RefCountedPtr<ThreadQuota>& thread_quota() { return thread_quota_; }
@@ -44,6 +47,11 @@ class ResourceQuota : public RefCounted<ResourceQuota>,
   // The default global resource quota
   static ResourceQuotaRefPtr Default();
 
+  static int ChannelArgsCompare(const ResourceQuota* a,
+                                const ResourceQuota* b) {
+    return QsortCompare(a, b);
+  }
+
  private:
   MemoryQuotaRefPtr memory_quota_;
   RefCountedPtr<ThreadQuota> thread_quota_;

data/src/core/lib/security/authorization/authorization_policy_provider.h

@@ -23,6 +23,13 @@
 struct grpc_authorization_policy_provider
     : public grpc_core::DualRefCounted<grpc_authorization_policy_provider> {
  public:
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER;
+  }
+  static int ChannelArgsCompare(const grpc_authorization_policy_provider* a,
+                                const grpc_authorization_policy_provider* b) {
+    return QsortCompare(a, b);
+  }
   struct AuthorizationEngines {
     grpc_core::RefCountedPtr<grpc_core::AuthorizationEngine> allow_engine;
     grpc_core::RefCountedPtr<grpc_core::AuthorizationEngine> deny_engine;

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -32,11 +32,9 @@ GrpcServerAuthzFilter::GrpcServerAuthzFilter(
       provider_(std::move(provider)) {}
 
 absl::StatusOr<GrpcServerAuthzFilter> GrpcServerAuthzFilter::Create(
-    const grpc_channel_args* args, ChannelFilter::Args) {
-  grpc_auth_context* auth_context = grpc_find_auth_context_in_args(args);
-  grpc_authorization_policy_provider* provider =
-      grpc_channel_args_find_pointer<grpc_authorization_policy_provider>(
-          args, GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER);
+    ChannelArgs args, ChannelFilter::Args) {
+  auto* auth_context = args.GetObject<grpc_auth_context>();
+  auto* provider = args.GetObject<grpc_authorization_policy_provider>();
   if (provider == nullptr) {
     return absl::InvalidArgumentError("Failed to get authorization provider.");
   }
@@ -49,7 +47,7 @@ absl::StatusOr<GrpcServerAuthzFilter> GrpcServerAuthzFilter::Create(
 }
 
 bool GrpcServerAuthzFilter::IsAuthorized(
-    const ClientInitialMetadata& initial_metadata) {
+    const ClientMetadataHandle& initial_metadata) {
   EvaluateArgs args(initial_metadata.get(), &per_channel_evaluate_args_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_trace)) {
     gpr_log(GPR_DEBUG,
@@ -92,14 +90,13 @@ bool GrpcServerAuthzFilter::IsAuthorized(
   return false;
 }
 
-ArenaPromise<TrailingMetadata> GrpcServerAuthzFilter::MakeCallPromise(
-    ClientInitialMetadata initial_metadata,
-    NextPromiseFactory next_promise_factory) {
-  if (!IsAuthorized(initial_metadata)) {
-    return ArenaPromise<TrailingMetadata>(Immediate(TrailingMetadata(
+ArenaPromise<ServerMetadataHandle> GrpcServerAuthzFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  if (!IsAuthorized(call_args.client_initial_metadata)) {
+    return ArenaPromise<ServerMetadataHandle>(Immediate(ServerMetadataHandle(
         absl::PermissionDeniedError("Unauthorized RPC request rejected."))));
   }
-  return next_promise_factory(std::move(initial_metadata));
+  return next_promise_factory(std::move(call_args));
 }
 
 const grpc_channel_filter GrpcServerAuthzFilter::kFilterVtable =

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -27,19 +27,18 @@ class GrpcServerAuthzFilter final : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilterVtable;
 
-  static absl::StatusOr<GrpcServerAuthzFilter> Create(
-      const grpc_channel_args* args, ChannelFilter::Args);
+  static absl::StatusOr<GrpcServerAuthzFilter> Create(ChannelArgs args,
+                                                      ChannelFilter::Args);
 
-  ArenaPromise<TrailingMetadata> MakeCallPromise(
-      ClientInitialMetadata initial_metadata,
-      NextPromiseFactory next_promise_factory) override;
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
  private:
   GrpcServerAuthzFilter(
       RefCountedPtr<grpc_auth_context> auth_context, grpc_endpoint* endpoint,
       RefCountedPtr<grpc_authorization_policy_provider> provider);
 
-  bool IsAuthorized(const ClientInitialMetadata& initial_metadata);
+  bool IsAuthorized(const ClientMetadataHandle& initial_metadata);
 
   RefCountedPtr<grpc_auth_context> auth_context_;
   EvaluateArgs::PerChannelArgs per_channel_evaluate_args_;

data/src/core/lib/security/context/security_context.h

@@ -43,6 +43,8 @@ struct grpc_auth_property_array {
 
 void grpc_auth_property_reset(grpc_auth_property* property);
 
+#define GRPC_AUTH_CONTEXT_ARG "grpc.auth_context"
+
 // This type is forward declared as a C struct and we cannot define it as a
 // class. Otherwise, compiler will complain about type mismatch due to
 // -Wmismatched-tags.
@@ -73,6 +75,12 @@ struct grpc_auth_context
     }
   }
 
+  static absl::string_view ChannelArgName() { return GRPC_AUTH_CONTEXT_ARG; }
+  static int ChannelArgsCompare(const grpc_auth_context* a,
+                                const grpc_auth_context* b) {
+    return QsortCompare(a, b);
+  }
+
   const grpc_auth_context* chained() const { return chained_.get(); }
   const grpc_auth_property_array& properties() const { return properties_; }
 
@@ -142,7 +150,6 @@ grpc_server_security_context* grpc_server_security_context_create(
 void grpc_server_security_context_destroy(void* ctx);
 
 /* --- Channel args for auth context --- */
-#define GRPC_AUTH_CONTEXT_ARG "grpc.auth_context"
 
 grpc_arg grpc_auth_context_to_arg(grpc_auth_context* c);
 grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg);

data/src/core/lib/security/credentials/alts/alts_credentials.cc

@@ -30,14 +30,12 @@
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 #include "src/core/lib/security/security_connector/alts/alts_security_connector.h"
 
-#define GRPC_CREDENTIALS_TYPE_ALTS "Alts"
 #define GRPC_ALTS_HANDSHAKER_SERVICE_URL "metadata.google.internal.:8080"
 
 grpc_alts_credentials::grpc_alts_credentials(
     const grpc_alts_credentials_options* options,
     const char* handshaker_service_url)
-    : grpc_channel_credentials(GRPC_CREDENTIALS_TYPE_ALTS),
-      options_(grpc_alts_credentials_options_copy(options)),
+    : options_(grpc_alts_credentials_options_copy(options)),
       handshaker_service_url_(handshaker_service_url == nullptr
                                   ? gpr_strdup(GRPC_ALTS_HANDSHAKER_SERVICE_URL)
                                   : gpr_strdup(handshaker_service_url)) {
@@ -58,11 +56,12 @@ grpc_alts_credentials::create_security_connector(
       this->Ref(), std::move(call_creds), target_name);
 }
 
+const char* grpc_alts_credentials::type() const { return "Alts"; }
+
 grpc_alts_server_credentials::grpc_alts_server_credentials(
     const grpc_alts_credentials_options* options,
     const char* handshaker_service_url)
-    : grpc_server_credentials(GRPC_CREDENTIALS_TYPE_ALTS),
-      options_(grpc_alts_credentials_options_copy(options)),
+    : options_(grpc_alts_credentials_options_copy(options)),
       handshaker_service_url_(handshaker_service_url == nullptr
                                   ? gpr_strdup(GRPC_ALTS_HANDSHAKER_SERVICE_URL)
                                   : gpr_strdup(handshaker_service_url)) {
@@ -80,6 +79,8 @@ grpc_alts_server_credentials::~grpc_alts_server_credentials() {
   gpr_free(handshaker_service_url_);
 }
 
+const char* grpc_alts_server_credentials::type() const { return "Alts"; }
+
 grpc_channel_credentials* grpc_alts_credentials_create_customized(
     const grpc_alts_credentials_options* options,
     const char* handshaker_service_url, bool enable_untrusted_alts) {

data/src/core/lib/security/credentials/alts/alts_credentials.h

@@ -39,6 +39,8 @@ class grpc_alts_credentials final : public grpc_channel_credentials {
       const char* target_name, const grpc_channel_args* args,
       grpc_channel_args** new_args) override;
 
+  const char* type() const override;
+
   const grpc_alts_credentials_options* options() const { return options_; }
   grpc_alts_credentials_options* mutable_options() { return options_; }
   const char* handshaker_service_url() const { return handshaker_service_url_; }
@@ -64,6 +66,8 @@ class grpc_alts_server_credentials final : public grpc_server_credentials {
   grpc_core::RefCountedPtr<grpc_server_security_connector>
   create_security_connector(const grpc_channel_args* /* args */) override;
 
+  const char* type() const override;
+
   const grpc_alts_credentials_options* options() const { return options_; }
   grpc_alts_credentials_options* mutable_options() { return options_; }
   const char* handshaker_service_url() const { return handshaker_service_url_; }

data/src/core/lib/security/credentials/call_creds_util.cc

@@ -31,7 +31,7 @@ struct ServiceUrlAndMethod {
 };
 
 ServiceUrlAndMethod MakeServiceUrlAndMethod(
-    const ClientInitialMetadata& initial_metadata,
+    const ClientMetadataHandle& initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args) {
   auto service =
       initial_metadata->get_pointer(HttpPathMetadata())->as_string_view();
@@ -65,13 +65,13 @@ ServiceUrlAndMethod MakeServiceUrlAndMethod(
 }  // namespace
 
 std::string MakeJwtServiceUrl(
-    const ClientInitialMetadata& initial_metadata,
+    const ClientMetadataHandle& initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args) {
   return MakeServiceUrlAndMethod(initial_metadata, args).service_url;
 }
 
 grpc_auth_metadata_context MakePluginAuthMetadataContext(
-    const ClientInitialMetadata& initial_metadata,
+    const ClientMetadataHandle& initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args) {
   auto fields = MakeServiceUrlAndMethod(initial_metadata, args);
   grpc_auth_metadata_context ctx;

data/src/core/lib/security/credentials/call_creds_util.h

@@ -29,12 +29,12 @@ namespace grpc_core {
 
 // Helper function to construct service URL for jwt call creds.
 std::string MakeJwtServiceUrl(
-    const ClientInitialMetadata& initial_metadata,
+    const ClientMetadataHandle& initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args);
 
 // Helper function to construct context for plugin call creds.
 grpc_auth_metadata_context MakePluginAuthMetadataContext(
-    const ClientInitialMetadata& initial_metadata,
+    const ClientMetadataHandle& initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args);
 
 }  // namespace grpc_core

data/src/core/lib/security/credentials/composite/composite_credentials.cc

@@ -37,25 +37,31 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/transport.h"
 
-namespace grpc_core {
-const char kCredentialsTypeComposite[] = "composite";
-}  // namespace grpc_core
+//
+// grpc_composite_channel_credentials
+//
+
+const char* grpc_composite_channel_credentials::type() const {
+  return "Composite";
+}
 
 /* -- Composite call credentials. -- */
 
-grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientMetadataHandle>>
 grpc_composite_call_credentials::GetRequestMetadata(
-    grpc_core::ClientInitialMetadata initial_metadata,
+    grpc_core::ClientMetadataHandle initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs* args) {
   auto self = Ref();
   return TrySeqIter(
       inner_.begin(), inner_.end(), std::move(initial_metadata),
       [self, args](const grpc_core::RefCountedPtr<grpc_call_credentials>& creds,
-                   grpc_core::ClientInitialMetadata initial_metadata) {
+                   grpc_core::ClientMetadataHandle initial_metadata) {
         return creds->GetRequestMetadata(std::move(initial_metadata), args);
       });
 }
 
+const char* grpc_composite_call_credentials::Type() { return "Composite"; }
+
 std::string grpc_composite_call_credentials::debug_string() {
   std::vector<std::string> outputs;
   for (auto& inner_cred : inner_) {
@@ -89,12 +95,11 @@ void grpc_composite_call_credentials::push_to_inner(
 
 grpc_composite_call_credentials::grpc_composite_call_credentials(
     grpc_core::RefCountedPtr<grpc_call_credentials> creds1,
-    grpc_core::RefCountedPtr<grpc_call_credentials> creds2)
-    : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) {
+    grpc_core::RefCountedPtr<grpc_call_credentials> creds2) {
   const bool creds1_is_composite =
-      strcmp(creds1->type(), GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0;
+      creds1->type() == grpc_composite_call_credentials::Type();
   const bool creds2_is_composite =
-      strcmp(creds2->type(), GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0;
+      creds2->type() == grpc_composite_call_credentials::Type();
   const size_t size = get_creds_array_size(creds1.get(), creds1_is_composite) +
                       get_creds_array_size(creds2.get(), creds2_is_composite);
   inner_.reserve(size);

data/src/core/lib/security/credentials/composite/composite_credentials.h

@@ -30,17 +30,12 @@
 
 /* -- Composite channel credentials. -- */
 
-namespace grpc_core {
-extern const char kCredentialsTypeComposite[];
-}
-
 class grpc_composite_channel_credentials : public grpc_channel_credentials {
  public:
   grpc_composite_channel_credentials(
       grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
       grpc_core::RefCountedPtr<grpc_call_credentials> call_creds)
-      : grpc_channel_credentials(grpc_core::kCredentialsTypeComposite),
-        inner_creds_(std::move(channel_creds)),
+      : inner_creds_(std::move(channel_creds)),
         call_creds_(std::move(call_creds)) {}
 
   ~grpc_composite_channel_credentials() override = default;
@@ -60,6 +55,8 @@ class grpc_composite_channel_credentials : public grpc_channel_credentials {
     return inner_creds_->update_arguments(args);
   }
 
+  const char* type() const override;
+
   const grpc_channel_credentials* inner_creds() const {
     return inner_creds_.get();
   }
@@ -90,8 +87,8 @@ class grpc_composite_call_credentials : public grpc_call_credentials {
       grpc_core::RefCountedPtr<grpc_call_credentials> creds2);
   ~grpc_composite_call_credentials() override = default;
 
-  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
-  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientMetadataHandle>>
+  GetRequestMetadata(grpc_core::ClientMetadataHandle initial_metadata,
                      const GetRequestMetadataArgs* args) override;
 
   grpc_security_level min_security_level() const override {
@@ -101,6 +98,10 @@ class grpc_composite_call_credentials : public grpc_call_credentials {
   const CallCredentialsList& inner() const { return inner_; }
   std::string debug_string() override;
 
+  static const char* Type();
+
+  const char* type() const override { return Type(); }
+
  private:
   int cmp_impl(const grpc_call_credentials* other) const override {
     // TODO(yashykt): Check if we can do something better here

data/src/core/lib/security/credentials/credentials.h

@@ -48,17 +48,6 @@ typedef enum {
 
 #define GRPC_FAKE_TRANSPORT_SECURITY_TYPE "fake"
 
-#define GRPC_CHANNEL_CREDENTIALS_TYPE_SSL "Ssl"
-#define GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY \
-  "FakeTransportSecurity"
-#define GRPC_CHANNEL_CREDENTIALS_TYPE_GOOGLE_DEFAULT "GoogleDefault"
-#define GRPC_CREDENTIALS_TYPE_INSECURE "insecure"
-
-#define GRPC_CALL_CREDENTIALS_TYPE_OAUTH2 "Oauth2"
-#define GRPC_CALL_CREDENTIALS_TYPE_JWT "Jwt"
-#define GRPC_CALL_CREDENTIALS_TYPE_IAM "Iam"
-#define GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE "Composite"
-
 #define GRPC_AUTHORIZATION_METADATA_KEY "authorization"
 #define GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY \
   "x-goog-iam-authorization-token"
@@ -103,13 +92,6 @@ void grpc_override_well_known_credentials_path_getter(
 struct grpc_channel_credentials
     : grpc_core::RefCounted<grpc_channel_credentials> {
  public:
-  // The pointer value \a type is used to uniquely identify a creds
-  // implementation for down-casting purposes. Every creds implementation should
-  // use a unique string instance, which should be returned by all instances of
-  // that creds implementation.
-  explicit grpc_channel_credentials(const char* type) : type_(type) {}
-  ~grpc_channel_credentials() override = default;
-
   // Creates a security connector for the channel. May also create new channel
   // args for the channel to be used in place of the passed in const args if
   // returned non NULL. In that case the caller is responsible for destroying
@@ -154,14 +136,16 @@ struct grpc_channel_credentials
     return cmp_impl(other);
   }
 
-  const char* type() const { return type_; }
+  // The pointer value \a type is used to uniquely identify a creds
+  // implementation for down-casting purposes. Every creds implementation should
+  // use a unique string instance, which should be returned by all instances of
+  // that creds implementation.
+  virtual const char* type() const = 0;
 
  private:
   // Implementation for `cmp` method intended to be overridden by subclasses.
-  // Only invoked if `type()` and `other->type()` compare equal as strings.
+  // Only invoked if `type()` and `other->type()` point to the same string.
   virtual int cmp_impl(const grpc_channel_credentials* other) const = 0;
-
-  const char* type_;
 };
 
 // TODO(roth): Once we eliminate insecure builds, find a better way to
@@ -209,15 +193,14 @@ struct grpc_call_credentials
   // use a unique string instance, which should be returned by all instances of
   // that creds implementation.
   explicit grpc_call_credentials(
-      const char* type,
       grpc_security_level min_security_level = GRPC_PRIVACY_AND_INTEGRITY)
-      : type_(type), min_security_level_(min_security_level) {}
+      : min_security_level_(min_security_level) {}
 
   ~grpc_call_credentials() override = default;
 
   virtual grpc_core::ArenaPromise<
-      absl::StatusOr<grpc_core::ClientInitialMetadata>>
-  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+      absl::StatusOr<grpc_core::ClientMetadataHandle>>
+  GetRequestMetadata(grpc_core::ClientMetadataHandle initial_metadata,
                      const GetRequestMetadataArgs* args) = 0;
 
   virtual grpc_security_level min_security_level() const {
@@ -240,14 +223,17 @@ struct grpc_call_credentials
     return "grpc_call_credentials did not provide debug string";
   }
 
-  const char* type() const { return type_; }
+  // The pointer value \a type is used to uniquely identify a creds
+  // implementation for down-casting purposes. Every creds implementation should
+  // use a unique string instance, which should be returned by all instances of
+  // that creds implementation.
+  virtual const char* type() const = 0;
 
  private:
   // Implementation for `cmp` method intended to be overridden by subclasses.
-  // Only invoked if `type()` and `other->type()` compare equal as strings.
+  // Only invoked if `type()` and `other->type()` point to the same string.
   virtual int cmp_impl(const grpc_call_credentials* other) const = 0;
 
-  const char* type_;
   const grpc_security_level min_security_level_;
 };
 
@@ -264,15 +250,13 @@ grpc_call_credentials* grpc_md_only_test_credentials_create(
 struct grpc_server_credentials
     : public grpc_core::RefCounted<grpc_server_credentials> {
  public:
-  explicit grpc_server_credentials(const char* type) : type_(type) {}
-
   ~grpc_server_credentials() override { DestroyProcessor(); }
 
   // Ownership of \a args is not passed.
   virtual grpc_core::RefCountedPtr<grpc_server_security_connector>
   create_security_connector(const grpc_channel_args* args) = 0;
 
-  const char* type() const { return type_; }
+  virtual const char* type() const = 0;
 
   const grpc_auth_metadata_processor& auth_metadata_processor() const {
     return processor_;
@@ -287,7 +271,6 @@ struct grpc_server_credentials
     }
   }
 
-  const char* type_;
   grpc_auth_metadata_processor processor_ =
       grpc_auth_metadata_processor();  // Zero-initialize the C struct.
 };

data/src/core/lib/security/credentials/fake/fake_credentials.cc

@@ -37,11 +37,6 @@
 namespace {
 class grpc_fake_channel_credentials final : public grpc_channel_credentials {
  public:
-  grpc_fake_channel_credentials()
-      : grpc_channel_credentials(
-            GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY) {}
-  ~grpc_fake_channel_credentials() override = default;
-
   grpc_core::RefCountedPtr<grpc_channel_security_connector>
   create_security_connector(
       grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
@@ -51,6 +46,8 @@ class grpc_fake_channel_credentials final : public grpc_channel_credentials {
         this->Ref(), std::move(call_creds), target, args);
   }
 
+  const char* type() const override { return "Fake"; }
+
  private:
   int cmp_impl(const grpc_channel_credentials* other) const override {
     // TODO(yashykt): Check if we can do something better here
@@ -61,15 +58,12 @@ class grpc_fake_channel_credentials final : public grpc_channel_credentials {
 
 class grpc_fake_server_credentials final : public grpc_server_credentials {
  public:
-  grpc_fake_server_credentials()
-      : grpc_server_credentials(
-            GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY) {}
-  ~grpc_fake_server_credentials() override = default;
-
   grpc_core::RefCountedPtr<grpc_server_security_connector>
   create_security_connector(const grpc_channel_args* /*args*/) override {
     return grpc_fake_server_security_connector_create(this->Ref());
   }
+
+  const char* type() const override { return "Fake"; }
 };
 }  // namespace
 
@@ -97,9 +91,9 @@ const char* grpc_fake_transport_get_expected_targets(
 
 /* -- Metadata-only test credentials. -- */
 
-grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientMetadataHandle>>
 grpc_md_only_test_credentials::GetRequestMetadata(
-    grpc_core::ClientInitialMetadata initial_metadata,
+    grpc_core::ClientMetadataHandle initial_metadata,
     const grpc_call_credentials::GetRequestMetadataArgs*) {
   initial_metadata->Append(
       key_.as_string_view(), value_.Ref(),
@@ -107,6 +101,8 @@ grpc_md_only_test_credentials::GetRequestMetadata(
   return grpc_core::Immediate(std::move(initial_metadata));
 }
 
+const char* grpc_md_only_test_credentials::Type() { return "MdOnlyTest"; }
+
 grpc_call_credentials* grpc_md_only_test_credentials_create(
     const char* md_key, const char* md_value) {
   return new grpc_md_only_test_credentials(md_key, md_value);

data/src/core/lib/security/credentials/fake/fake_credentials.h

@@ -60,16 +60,19 @@ const char* grpc_fake_transport_get_expected_targets(
 class grpc_md_only_test_credentials : public grpc_call_credentials {
  public:
   grpc_md_only_test_credentials(const char* md_key, const char* md_value)
-      : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_OAUTH2,
-                              GRPC_SECURITY_NONE),
+      : grpc_call_credentials(GRPC_SECURITY_NONE),
         key_(grpc_core::Slice::FromCopiedString(md_key)),
         value_(grpc_core::Slice::FromCopiedString(md_value)) {}
 
-  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
-  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientMetadataHandle>>
+  GetRequestMetadata(grpc_core::ClientMetadataHandle initial_metadata,
                      const GetRequestMetadataArgs* args) override;
 
-  std::string debug_string() override { return "MD only Test Credentials"; };
+  std::string debug_string() override { return "MD only Test Credentials"; }
+
+  static const char* Type();
+
+  const char* type() const override { return Type(); }
 
  private:
   int cmp_impl(const grpc_call_credentials* other) const override {

data/src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -138,6 +138,10 @@ grpc_channel_args* grpc_google_default_channel_credentials::update_arguments(
   return updated;
 }
 
+const char* grpc_google_default_channel_credentials::type() const {
+  return "GoogleDefault";
+}
+
 static void on_metadata_server_detection_http_response(
     void* user_data, grpc_error_handle error) {
   metadata_server_detector* detector =

data/src/core/lib/security/credentials/google_default/google_default_credentials.h

@@ -46,9 +46,7 @@ class grpc_google_default_channel_credentials
   grpc_google_default_channel_credentials(
       grpc_core::RefCountedPtr<grpc_channel_credentials> alts_creds,
       grpc_core::RefCountedPtr<grpc_channel_credentials> ssl_creds)
-      : grpc_channel_credentials(GRPC_CHANNEL_CREDENTIALS_TYPE_GOOGLE_DEFAULT),
-        alts_creds_(std::move(alts_creds)),
-        ssl_creds_(std::move(ssl_creds)) {}
+      : alts_creds_(std::move(alts_creds)), ssl_creds_(std::move(ssl_creds)) {}
 
   ~grpc_google_default_channel_credentials() override = default;
 
@@ -60,6 +58,8 @@ class grpc_google_default_channel_credentials
 
   grpc_channel_args* update_arguments(grpc_channel_args* args) override;
 
+  const char* type() const override;
+
   const grpc_channel_credentials* alts_creds() const {
     return alts_creds_.get();
   }