grpc 1.44.0.pre2 → 1.45.0

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

@@ -61,14 +61,14 @@ class ExternalAccountCredentials
   // This is a helper struct to pass information between multiple callback based
   // asynchronous calls.
   struct HTTPRequestContext {
-    HTTPRequestContext(grpc_polling_entity* pollent, grpc_millis deadline)
+    HTTPRequestContext(grpc_polling_entity* pollent, Timestamp deadline)
         : pollent(pollent), deadline(deadline) {}
     ~HTTPRequestContext() { grpc_http_response_destroy(&response); }
 
     // Contextual parameters passed from
     // grpc_oauth2_token_fetcher_credentials::fetch_oauth2().
     grpc_polling_entity* pollent;
-    grpc_millis deadline;
+    Timestamp deadline;
 
     // Reusable token fetch http response and closure.
     grpc_closure closure;
@@ -89,7 +89,7 @@ class ExternalAccountCredentials
   // when grpc_oauth2_token_fetcher_credentials request a new access token.
   void fetch_oauth2(grpc_credentials_metadata_request* req,
                     grpc_polling_entity* pollent, grpc_iomgr_cb_func cb,
-                    grpc_millis deadline) override;
+                    Timestamp deadline) override;
 
   void OnRetrieveSubjectTokenInternal(absl::string_view subject_token,
                                       grpc_error_handle error);
@@ -107,6 +107,7 @@ class ExternalAccountCredentials
   Options options_;
   std::vector<std::string> scopes_;
 
+  OrphanablePtr<HttpRequest> http_request_;
   HTTPRequestContext* ctx_ = nullptr;
   grpc_credentials_metadata_request* metadata_req_ = nullptr;
   grpc_iomgr_cb_func response_cb_ = nullptr;

data/src/core/lib/security/credentials/external/file_external_account_credentials.cc

@@ -21,7 +21,6 @@
 
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_utils.h"
 
 namespace grpc_core {
 

data/src/core/lib/security/credentials/external/url_external_account_credentials.cc

@@ -21,6 +21,9 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 
+#include "src/core/lib/http/httpcli_ssl_credentials.h"
+#include "src/core/lib/transport/error_utils.h"
+
 namespace grpc_core {
 
 RefCountedPtr<UrlExternalAccountCredentials>
@@ -120,31 +123,48 @@ void UrlExternalAccountCredentials::RetrieveSubjectToken(
             "Missing HTTPRequestContext to start subject token retrieval."));
     return;
   }
+  auto url_for_request =
+      URI::Create(url_.scheme(), url_.authority(), url_full_path_,
+                  {} /* query params */, "" /* fragment */);
+  if (!url_for_request.ok()) {
+    FinishRetrieveSubjectToken(
+        "", absl_status_to_grpc_error(url_for_request.status()));
+    return;
+  }
   ctx_ = ctx;
   cb_ = cb;
-  grpc_httpcli_request request;
-  memset(&request, 0, sizeof(grpc_httpcli_request));
-  request.host = const_cast<char*>(url_.authority().c_str());
-  request.http.path = gpr_strdup(url_full_path_.c_str());
+  grpc_http_request request;
+  memset(&request, 0, sizeof(grpc_http_request));
+  request.path = gpr_strdup(url_full_path_.c_str());
   grpc_http_header* headers = nullptr;
-  request.http.hdr_count = headers_.size();
+  request.hdr_count = headers_.size();
   headers = static_cast<grpc_http_header*>(
-      gpr_malloc(sizeof(grpc_http_header) * request.http.hdr_count));
+      gpr_malloc(sizeof(grpc_http_header) * request.hdr_count));
   int i = 0;
   for (auto const& header : headers_) {
     headers[i].key = gpr_strdup(header.first.c_str());
     headers[i].value = gpr_strdup(header.second.c_str());
     ++i;
   }
-  request.http.hdrs = headers;
-  request.handshaker =
-      url_.scheme() == "https" ? &grpc_httpcli_ssl : &grpc_httpcli_plaintext;
+  request.hdrs = headers;
   grpc_http_response_destroy(&ctx_->response);
   ctx_->response = {};
   GRPC_CLOSURE_INIT(&ctx_->closure, OnRetrieveSubjectToken, this, nullptr);
-  grpc_httpcli_get(ctx_->pollent, ResourceQuota::Default(), &request,
-                   ctx_->deadline, &ctx_->closure, &ctx_->response);
-  grpc_http_request_destroy(&request.http);
+  GPR_ASSERT(http_request_ == nullptr);
+  RefCountedPtr<grpc_channel_credentials> http_request_creds;
+  if (url_.scheme() == "http") {
+    http_request_creds = RefCountedPtr<grpc_channel_credentials>(
+        grpc_insecure_credentials_create());
+  } else {
+    http_request_creds = RefCountedPtr<grpc_channel_credentials>(
+        CreateHttpRequestSSLCredentials());
+  }
+  http_request_ =
+      HttpRequest::Get(std::move(*url_for_request), nullptr /* channel args */,
+                       ctx_->pollent, &request, ctx_->deadline, &ctx_->closure,
+                       &ctx_->response, std::move(http_request_creds));
+  http_request_->Start();
+  grpc_http_request_destroy(&request);
 }
 
 void UrlExternalAccountCredentials::OnRetrieveSubjectToken(
@@ -156,6 +176,7 @@ void UrlExternalAccountCredentials::OnRetrieveSubjectToken(
 
 void UrlExternalAccountCredentials::OnRetrieveSubjectTokenInternal(
     grpc_error_handle error) {
+  http_request_.reset();
   if (error != GRPC_ERROR_NONE) {
     FinishRetrieveSubjectToken("", error);
     return;

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

@@ -51,6 +51,7 @@ class UrlExternalAccountCredentials final : public ExternalAccountCredentials {
   std::string format_type_;
   std::string format_subject_token_field_name_;
 
+  OrphanablePtr<HttpRequest> http_request_;
   HTTPRequestContext* ctx_ = nullptr;
   std::function<void(std::string, grpc_error_handle)> cb_ = nullptr;
 };

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

@@ -29,6 +29,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/executor.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/security_connector/fake/fake_security_connector.h"
 
 /* -- Fake transport security credentials. -- */
@@ -49,6 +50,13 @@ class grpc_fake_channel_credentials final : public grpc_channel_credentials {
     return grpc_fake_channel_security_connector_create(
         this->Ref(), std::move(call_creds), target, args);
   }
+
+ private:
+  int cmp_impl(const grpc_channel_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return grpc_core::QsortCompare(
+        static_cast<const grpc_channel_credentials*>(this), other);
+  }
 };
 
 class grpc_fake_server_credentials final : public grpc_server_credentials {
@@ -89,26 +97,17 @@ const char* grpc_fake_transport_get_expected_targets(
 
 /* -- Metadata-only test credentials. -- */
 
-bool grpc_md_only_test_credentials::get_request_metadata(
-    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context /*context*/,
-    grpc_core::CredentialsMetadataArray* md_array,
-    grpc_closure* on_request_metadata, grpc_error_handle* /*error*/) {
-  md_array->emplace_back(key_.Ref(), value_.Ref());
-  if (is_async_) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_request_metadata,
-                            GRPC_ERROR_NONE);
-    return false;
-  }
-  return true;
-}
-
-void grpc_md_only_test_credentials::cancel_get_request_metadata(
-    grpc_core::CredentialsMetadataArray* /*md_array*/,
-    grpc_error_handle error) {
-  GRPC_ERROR_UNREF(error);
+grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+grpc_md_only_test_credentials::GetRequestMetadata(
+    grpc_core::ClientInitialMetadata initial_metadata,
+    const grpc_call_credentials::GetRequestMetadataArgs*) {
+  initial_metadata->Append(
+      key_.as_string_view(), value_.Ref(),
+      [](absl::string_view, const grpc_core::Slice&) { abort(); });
+  return grpc_core::Immediate(std::move(initial_metadata));
 }
 
 grpc_call_credentials* grpc_md_only_test_credentials_create(
-    const char* md_key, const char* md_value, bool is_async) {
-  return new grpc_md_only_test_credentials(md_key, md_value, is_async);
+    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

@@ -59,30 +59,27 @@ 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,
-                                bool is_async)
+  grpc_md_only_test_credentials(const char* md_key, const char* md_value)
       : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_OAUTH2,
                               GRPC_SECURITY_NONE),
         key_(grpc_core::Slice::FromCopiedString(md_key)),
-        value_(grpc_core::Slice::FromCopiedString(md_value)),
-        is_async_(is_async) {}
+        value_(grpc_core::Slice::FromCopiedString(md_value)) {}
 
-  bool get_request_metadata(grpc_polling_entity* pollent,
-                            grpc_auth_metadata_context context,
-                            grpc_core::CredentialsMetadataArray* md_array,
-                            grpc_closure* on_request_metadata,
-                            grpc_error_handle* error) override;
-
-  void cancel_get_request_metadata(
-      grpc_core::CredentialsMetadataArray* md_array,
-      grpc_error_handle error) override;
+  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+                     const GetRequestMetadataArgs* args) override;
 
   std::string debug_string() override { return "MD only Test Credentials"; };
 
  private:
+  int cmp_impl(const grpc_call_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return grpc_core::QsortCompare(
+        static_cast<const grpc_call_credentials*>(this), other);
+  }
+
   grpc_core::Slice key_;
   grpc_core::Slice value_;
-  bool is_async_;
 };
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_FAKE_FAKE_CREDENTIALS_H */

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

@@ -171,26 +171,31 @@ static void destroy_pollset(void* p, grpc_error_handle /*e*/) {
 
 static int is_metadata_server_reachable() {
   metadata_server_detector detector;
-  grpc_httpcli_request request;
+  grpc_http_request request;
   grpc_closure destroy_closure;
   /* The http call is local. If it takes more than one sec, it is for sure not
      on compute engine. */
-  grpc_millis max_detection_delay = GPR_MS_PER_SEC;
+  const auto max_detection_delay = grpc_core::Duration::Seconds(1);
   grpc_pollset* pollset =
       static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
   grpc_pollset_init(pollset, &g_polling_mu);
   detector.pollent = grpc_polling_entity_create_from_pollset(pollset);
   detector.is_done = 0;
   detector.success = 0;
-  memset(&request, 0, sizeof(grpc_httpcli_request));
-  request.host = const_cast<char*>(GRPC_COMPUTE_ENGINE_DETECTION_HOST);
-  request.http.path = const_cast<char*>("/");
-  grpc_httpcli_get(
-      &detector.pollent, grpc_core::ResourceQuota::Default(), &request,
+  memset(&request, 0, sizeof(grpc_http_request));
+  auto uri =
+      grpc_core::URI::Create("http", GRPC_COMPUTE_ENGINE_DETECTION_HOST, "/",
+                             {} /* query params */, "" /* fragment */);
+  GPR_ASSERT(uri.ok());  // params are hardcoded
+  auto http_request = grpc_core::HttpRequest::Get(
+      std::move(*uri), nullptr /* channel args */, &detector.pollent, &request,
       grpc_core::ExecCtx::Get()->Now() + max_detection_delay,
       GRPC_CLOSURE_CREATE(on_metadata_server_detection_http_response, &detector,
                           grpc_schedule_on_exec_ctx),
-      &detector.response);
+      &detector.response,
+      grpc_core::RefCountedPtr<grpc_channel_credentials>(
+          grpc_insecure_credentials_create()));
+  http_request->Start();
   grpc_core::ExecCtx::Get()->Flush();
   /* Block until we get the response. This is not ideal but this should only be
     called once for the lifetime of the process by the default credentials. */
@@ -200,12 +205,13 @@ static int is_metadata_server_reachable() {
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(grpc_polling_entity_pollset(&detector.pollent),
-                              &worker, GRPC_MILLIS_INF_FUTURE))) {
+                              &worker, grpc_core::Timestamp::InfFuture()))) {
       detector.is_done = 1;
       detector.success = 0;
     }
   }
   gpr_mu_unlock(g_polling_mu);
+  http_request.reset();
   GRPC_CLOSURE_INIT(&destroy_closure, destroy_pollset,
                     grpc_polling_entity_pollset(&detector.pollent),
                     grpc_schedule_on_exec_ctx);

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

@@ -66,6 +66,12 @@ class grpc_google_default_channel_credentials
   const grpc_channel_credentials* ssl_creds() const { return ssl_creds_.get(); }
 
  private:
+  int cmp_impl(const grpc_channel_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return grpc_core::QsortCompare(
+        static_cast<const grpc_channel_credentials*>(this), other);
+  }
+
   grpc_core::RefCountedPtr<grpc_channel_credentials> alts_creds_;
   grpc_core::RefCountedPtr<grpc_channel_credentials> ssl_creds_;
 };

data/src/core/lib/security/credentials/iam/iam_credentials.cc

@@ -28,27 +28,22 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/surface/api_trace.h"
 
-bool grpc_google_iam_credentials::get_request_metadata(
-    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context /*context*/,
-    grpc_core::CredentialsMetadataArray* md_array,
-    grpc_closure* /*on_request_metadata*/, grpc_error_handle* /*error*/) {
+grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+grpc_google_iam_credentials::GetRequestMetadata(
+    grpc_core::ClientInitialMetadata initial_metadata,
+    const grpc_call_credentials::GetRequestMetadataArgs*) {
   if (token_.has_value()) {
-    md_array->emplace_back(grpc_core::Slice::FromStaticString(
-                               GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY),
-                           token_->Ref());
+    initial_metadata->Append(
+        GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, token_->Ref(),
+        [](absl::string_view, const grpc_core::Slice&) { abort(); });
   }
-  md_array->emplace_back(grpc_core::Slice::FromStaticString(
-                             GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY),
-                         authority_selector_.Ref());
-  return true;
-}
-
-void grpc_google_iam_credentials::cancel_get_request_metadata(
-    grpc_core::CredentialsMetadataArray* /*md_array*/,
-    grpc_error_handle error) {
-  GRPC_ERROR_UNREF(error);
+  initial_metadata->Append(
+      GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, authority_selector_.Ref(),
+      [](absl::string_view, const grpc_core::Slice&) { abort(); });
+  return grpc_core::Immediate(std::move(initial_metadata));
 }
 
 grpc_google_iam_credentials::grpc_google_iam_credentials(

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

@@ -30,18 +30,19 @@ class grpc_google_iam_credentials : public grpc_call_credentials {
   grpc_google_iam_credentials(const char* token,
                               const char* authority_selector);
 
-  bool get_request_metadata(grpc_polling_entity* pollent,
-                            grpc_auth_metadata_context context,
-                            grpc_core::CredentialsMetadataArray* md_array,
-                            grpc_closure* on_request_metadata,
-                            grpc_error_handle* error) override;
-
-  void cancel_get_request_metadata(
-      grpc_core::CredentialsMetadataArray* md_array,
-      grpc_error_handle error) override;
+  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+                     const GetRequestMetadataArgs* args) override;
+
   std::string debug_string() override { return debug_string_; }
 
  private:
+  int cmp_impl(const grpc_call_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return grpc_core::QsortCompare(
+        static_cast<const grpc_call_credentials*>(this), other);
+  }
+
   const absl::optional<grpc_core::Slice> token_;
   const grpc_core::Slice authority_selector_;
   const std::string debug_string_;

data/src/core/lib/security/credentials/insecure/insecure_credentials.cc

@@ -18,19 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc_security.h>
-
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/insecure/insecure_security_connector.h"
 
 namespace grpc_core {
 namespace {
 
-constexpr char kCredentialsTypeInsecure[] = "insecure";
-
 class InsecureCredentials final : public grpc_channel_credentials {
  public:
-  InsecureCredentials() : grpc_channel_credentials(kCredentialsTypeInsecure) {}
+  InsecureCredentials()
+      : grpc_channel_credentials(GRPC_CREDENTIALS_TYPE_INSECURE) {}
 
   RefCountedPtr<grpc_channel_security_connector> create_security_connector(
       RefCountedPtr<grpc_call_credentials> call_creds,
@@ -39,12 +36,18 @@ class InsecureCredentials final : public grpc_channel_credentials {
     return MakeRefCounted<InsecureChannelSecurityConnector>(
         Ref(), std::move(call_creds));
   }
+
+ private:
+  int cmp_impl(const grpc_channel_credentials* /* other */) const override {
+    // All insecure credentials objects should compare equal.
+    return 0;
+  }
 };
 
 class InsecureServerCredentials final : public grpc_server_credentials {
  public:
   InsecureServerCredentials()
-      : grpc_server_credentials(kCredentialsTypeInsecure) {}
+      : grpc_server_credentials(GRPC_CREDENTIALS_TYPE_INSECURE) {}
 
   RefCountedPtr<grpc_server_security_connector> create_security_connector(
       const grpc_channel_args* /* args */) override {
@@ -56,7 +59,10 @@ class InsecureServerCredentials final : public grpc_server_credentials {
 }  // namespace grpc_core
 
 grpc_channel_credentials* grpc_insecure_credentials_create() {
-  return new grpc_core::InsecureCredentials();
+  // Create a singleton object for InsecureCredentials so that channels to the
+  // same target with InsecureCredentials can reuse the subchannels.
+  static auto* creds = new grpc_core::InsecureCredentials();
+  return creds->Ref().release();
 }
 
 grpc_server_credentials* grpc_insecure_server_credentials_create() {

data/src/core/lib/security/credentials/jwt/jwt_credentials.cc

@@ -34,6 +34,8 @@
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/security/credentials/call_creds_util.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -47,22 +49,21 @@ grpc_service_account_jwt_access_credentials::
   gpr_mu_destroy(&cache_mu_);
 }
 
-bool grpc_service_account_jwt_access_credentials::get_request_metadata(
-    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context context,
-    grpc_core::CredentialsMetadataArray* md_array,
-    grpc_closure* /*on_request_metadata*/, grpc_error_handle* error) {
+grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+grpc_service_account_jwt_access_credentials::GetRequestMetadata(
+    grpc_core::ClientInitialMetadata initial_metadata,
+    const grpc_call_credentials::GetRequestMetadataArgs* args) {
   gpr_timespec refresh_threshold = gpr_time_from_seconds(
       GRPC_SECURE_TOKEN_REFRESH_THRESHOLD_SECS, GPR_TIMESPAN);
 
   // Remove service name from service_url to follow the audience format
   // dictated in https://google.aip.dev/auth/4111.
-  absl::StatusOr<std::string> uri =
-      grpc_core::RemoveServiceNameFromJwtUri(context.service_url);
+  absl::StatusOr<std::string> uri = grpc_core::RemoveServiceNameFromJwtUri(
+      grpc_core::MakeJwtServiceUrl(initial_metadata, args));
   if (!uri.ok()) {
-    *error = absl_status_to_grpc_error(uri.status());
-    return true;
+    return grpc_core::Immediate(uri.status());
   }
-  /* See if we can return a cached jwt. */
+  // See if we can return a cached jwt.
   absl::optional<grpc_core::Slice> jwt_value;
   {
     gpr_mu_lock(&cache_mu_);
@@ -77,7 +78,7 @@ bool grpc_service_account_jwt_access_credentials::get_request_metadata(
 
   if (!jwt_value.has_value()) {
     char* jwt = nullptr;
-    /* Generate a new jwt. */
+    // Generate a new jwt.
     gpr_mu_lock(&cache_mu_);
     cached_.reset();
     jwt = grpc_jwt_encode_and_sign(&key_, uri->c_str(), jwt_lifetime_, nullptr);
@@ -91,20 +92,15 @@ bool grpc_service_account_jwt_access_credentials::get_request_metadata(
     gpr_mu_unlock(&cache_mu_);
   }
 
-  if (jwt_value.has_value()) {
-    md_array->emplace_back(
-        grpc_core::Slice::FromStaticString(GRPC_AUTHORIZATION_METADATA_KEY),
-        std::move(*jwt_value));
-  } else {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Could not generate JWT.");
+  if (!jwt_value.has_value()) {
+    return grpc_core::Immediate(
+        absl::UnauthenticatedError("Could not generate JWT."));
   }
-  return true;
-}
 
-void grpc_service_account_jwt_access_credentials::cancel_get_request_metadata(
-    grpc_core::CredentialsMetadataArray* /*md_array*/,
-    grpc_error_handle error) {
-  GRPC_ERROR_UNREF(error);
+  initial_metadata->Append(
+      GRPC_AUTHORIZATION_METADATA_KEY, std::move(*jwt_value),
+      [](absl::string_view, const grpc_core::Slice&) { abort(); });
+  return grpc_core::Immediate(std::move(initial_metadata));
 }
 
 grpc_service_account_jwt_access_credentials::

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

@@ -38,15 +38,9 @@ class grpc_service_account_jwt_access_credentials
                                               gpr_timespec token_lifetime);
   ~grpc_service_account_jwt_access_credentials() override;
 
-  bool get_request_metadata(grpc_polling_entity* pollent,
-                            grpc_auth_metadata_context context,
-                            grpc_core::CredentialsMetadataArray* md_array,
-                            grpc_closure* on_request_metadata,
-                            grpc_error_handle* error) override;
-
-  void cancel_get_request_metadata(
-      grpc_core::CredentialsMetadataArray* md_array,
-      grpc_error_handle error) override;
+  grpc_core::ArenaPromise<absl::StatusOr<grpc_core::ClientInitialMetadata>>
+  GetRequestMetadata(grpc_core::ClientInitialMetadata initial_metadata,
+                     const GetRequestMetadataArgs* args) override;
 
   const gpr_timespec& jwt_lifetime() const { return jwt_lifetime_; }
   const grpc_auth_json_key& key() const { return key_; }
@@ -59,6 +53,12 @@ class grpc_service_account_jwt_access_credentials
   };
 
  private:
+  int cmp_impl(const grpc_call_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return grpc_core::QsortCompare(
+        static_cast<const grpc_call_credentials*>(this), other);
+  }
+
   // Have a simple cache for now with just 1 entry. We could have a map based on
   // the service_url for a more sophisticated one.
   gpr_mu cache_mu_;