grpc 1.25.0 → 1.26.0

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

@@ -80,8 +80,9 @@ static void composite_call_metadata_cb(void* arg, grpc_error* error) {
     }
     // We're done!
   }
-  GRPC_CLOSURE_SCHED(ctx->on_request_metadata, GRPC_ERROR_REF(error));
-  gpr_free(ctx);
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, ctx->on_request_metadata,
+                          GRPC_ERROR_REF(error));
+  delete ctx;
 }
 
 bool grpc_composite_call_credentials::get_request_metadata(
@@ -89,7 +90,7 @@ bool grpc_composite_call_credentials::get_request_metadata(
     grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
     grpc_error** error) {
   grpc_composite_call_credentials_metadata_context* ctx;
-  ctx = grpc_core::New<grpc_composite_call_credentials_metadata_context>(
+  ctx = new grpc_composite_call_credentials_metadata_context(
       this, pollent, auth_md_context, md_array, on_request_metadata);
   bool synchronous = true;
   const CallCredentialsList& inner = ctx->composite_creds->inner();
@@ -103,7 +104,7 @@ bool grpc_composite_call_credentials::get_request_metadata(
       break;
     }
   }
-  if (synchronous) grpc_core::Delete(ctx);
+  if (synchronous) delete ctx;
   return synchronous;
 }
 
@@ -204,6 +205,6 @@ grpc_channel_credentials* grpc_composite_channel_credentials_create(
       "grpc_composite_channel_credentials_create(channel_creds=%p, "
       "call_creds=%p, reserved=%p)",
       3, (channel_creds, call_creds, reserved));
-  return grpc_core::New<grpc_composite_channel_credentials>(
-      channel_creds->Ref(), call_creds->Ref());
+  return new grpc_composite_channel_credentials(channel_creds->Ref(),
+                                                call_creds->Ref());
 }

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

@@ -45,18 +45,18 @@ void grpc_channel_credentials_release(grpc_channel_credentials* creds) {
   if (creds) creds->Unref();
 }
 
-static grpc_core::Map<grpc_core::UniquePtr<char>,
-                      grpc_core::RefCountedPtr<grpc_channel_credentials>,
-                      grpc_core::StringLess>* g_grpc_control_plane_creds;
+static std::map<grpc_core::UniquePtr<char>,
+                grpc_core::RefCountedPtr<grpc_channel_credentials>,
+                grpc_core::StringLess>* g_grpc_control_plane_creds;
 static gpr_mu g_control_plane_creds_mu;
 
 static void do_control_plane_creds_init() {
   gpr_mu_init(&g_control_plane_creds_mu);
   GPR_ASSERT(g_grpc_control_plane_creds == nullptr);
-  g_grpc_control_plane_creds = grpc_core::New<
-      grpc_core::Map<grpc_core::UniquePtr<char>,
-                     grpc_core::RefCountedPtr<grpc_channel_credentials>,
-                     grpc_core::StringLess>>();
+  g_grpc_control_plane_creds =
+      new std::map<grpc_core::UniquePtr<char>,
+                   grpc_core::RefCountedPtr<grpc_channel_credentials>,
+                   grpc_core::StringLess>();
 }
 
 void grpc_control_plane_credentials_init() {
@@ -65,7 +65,7 @@ void grpc_control_plane_credentials_init() {
 }
 
 void grpc_test_only_control_plane_credentials_destroy() {
-  grpc_core::Delete(g_grpc_control_plane_creds);
+  delete g_grpc_control_plane_creds;
   g_grpc_control_plane_creds = nullptr;
   gpr_mu_destroy(&g_control_plane_creds_mu);
 }

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

@@ -148,9 +148,9 @@ struct grpc_channel_credentials
 
  private:
   const char* type_;
-  grpc_core::Map<grpc_core::UniquePtr<char>,
-                 grpc_core::RefCountedPtr<grpc_channel_credentials>,
-                 grpc_core::StringLess>
+  std::map<grpc_core::UniquePtr<char>,
+           grpc_core::RefCountedPtr<grpc_channel_credentials>,
+           grpc_core::StringLess>
       local_control_plane_creds_;
 };
 
@@ -314,12 +314,12 @@ struct grpc_credentials_metadata_request {
 inline grpc_credentials_metadata_request*
 grpc_credentials_metadata_request_create(
     grpc_core::RefCountedPtr<grpc_call_credentials> creds) {
-  return grpc_core::New<grpc_credentials_metadata_request>(std::move(creds));
+  return new grpc_credentials_metadata_request(std::move(creds));
 }
 
 inline void grpc_credentials_metadata_request_destroy(
     grpc_credentials_metadata_request* r) {
-  grpc_core::Delete(r);
+  delete r;
 }
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_CREDENTIALS_H */

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

@@ -66,12 +66,12 @@ class grpc_fake_server_credentials final : public grpc_server_credentials {
 }  // namespace
 
 grpc_channel_credentials* grpc_fake_transport_security_credentials_create() {
-  return grpc_core::New<grpc_fake_channel_credentials>();
+  return new grpc_fake_channel_credentials();
 }
 
 grpc_server_credentials*
 grpc_fake_transport_security_server_credentials_create() {
-  return grpc_core::New<grpc_fake_server_credentials>();
+  return new grpc_fake_server_credentials();
 }
 
 grpc_arg grpc_fake_transport_expected_targets_arg(char* expected_targets) {
@@ -94,7 +94,8 @@ bool grpc_md_only_test_credentials::get_request_metadata(
     grpc_error** /*error*/) {
   grpc_credentials_mdelem_array_add(md_array, md_);
   if (is_async_) {
-    GRPC_CLOSURE_SCHED(on_request_metadata, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_request_metadata,
+                            GRPC_ERROR_NONE);
     return false;
   }
   return true;
@@ -107,6 +108,5 @@ void grpc_md_only_test_credentials::cancel_get_request_metadata(
 
 grpc_call_credentials* grpc_md_only_test_credentials_create(
     const char* md_key, const char* md_value, bool is_async) {
-  return grpc_core::New<grpc_md_only_test_credentials>(md_key, md_value,
-                                                       is_async);
+  return new grpc_md_only_test_credentials(md_key, md_value, is_async);
 }

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

@@ -154,7 +154,7 @@ static void on_metadata_server_detection_http_response(void* user_data,
   gpr_mu_unlock(g_polling_mu);
 }
 
-static void destroy_pollset(void* p, grpc_error* e) {
+static void destroy_pollset(void* p, grpc_error* /*e*/) {
   grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
 }
 

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

@@ -35,15 +35,15 @@ grpc_google_iam_credentials::~grpc_google_iam_credentials() {
 }
 
 bool grpc_google_iam_credentials::get_request_metadata(
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context /*context*/,
+    grpc_credentials_mdelem_array* md_array,
+    grpc_closure* /*on_request_metadata*/, grpc_error** /*error*/) {
   grpc_credentials_mdelem_array_append(md_array, &md_array_);
   return true;
 }
 
 void grpc_google_iam_credentials::cancel_get_request_metadata(
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_credentials_mdelem_array* /*md_array*/, grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 

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

@@ -50,9 +50,9 @@ grpc_service_account_jwt_access_credentials::
 }
 
 bool grpc_service_account_jwt_access_credentials::get_request_metadata(
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context context,
+    grpc_credentials_mdelem_array* md_array,
+    grpc_closure* /*on_request_metadata*/, grpc_error** error) {
   gpr_timespec refresh_threshold = gpr_time_from_seconds(
       GRPC_SECURE_TOKEN_REFRESH_THRESHOLD_SECS, GPR_TIMESPAN);
 
@@ -104,7 +104,7 @@ bool grpc_service_account_jwt_access_credentials::get_request_metadata(
 }
 
 void grpc_service_account_jwt_access_credentials::cancel_get_request_metadata(
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_credentials_mdelem_array* /*md_array*/, grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 

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

@@ -636,7 +636,7 @@ end:
   return result;
 }
 
-static void on_keys_retrieved(void* user_data, grpc_error* error) {
+static void on_keys_retrieved(void* user_data, grpc_error* /*error*/) {
   verifier_cb_ctx* ctx = static_cast<verifier_cb_ctx*>(user_data);
   grpc_json* json = json_from_http(&ctx->responses[HTTP_RESPONSE_KEYS]);
   EVP_PKEY* verification_key = nullptr;
@@ -676,7 +676,7 @@ end:
   verifier_cb_ctx_destroy(ctx);
 }
 
-static void on_openid_config_retrieved(void* user_data, grpc_error* error) {
+static void on_openid_config_retrieved(void* user_data, grpc_error* /*error*/) {
   const grpc_json* cur;
   verifier_cb_ctx* ctx = static_cast<verifier_cb_ctx*>(user_data);
   const grpc_http_response* response = &ctx->responses[HTTP_RESPONSE_OPENID];

data/src/core/lib/security/credentials/local/local_credentials.cc

@@ -33,7 +33,7 @@ grpc_core::RefCountedPtr<grpc_channel_security_connector>
 grpc_local_credentials::create_security_connector(
     grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
     const char* target_name, const grpc_channel_args* args,
-    grpc_channel_args** new_args) {
+    grpc_channel_args** /*new_args*/) {
   return grpc_local_channel_security_connector_create(
       this->Ref(), std::move(request_metadata_creds), args, target_name);
 }
@@ -50,7 +50,7 @@ grpc_local_credentials::grpc_local_credentials(
 
 grpc_channel_credentials* grpc_local_credentials_create(
     grpc_local_connect_type connect_type) {
-  return grpc_core::New<grpc_local_credentials>(connect_type);
+  return new grpc_local_credentials(connect_type);
 }
 
 grpc_local_server_credentials::grpc_local_server_credentials(
@@ -60,5 +60,5 @@ grpc_local_server_credentials::grpc_local_server_credentials(
 
 grpc_server_credentials* grpc_local_server_credentials_create(
     grpc_local_connect_type connect_type) {
-  return grpc_core::New<grpc_local_server_credentials>(connect_type);
+  return new grpc_local_server_credentials(connect_type);
 }

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc

@@ -256,7 +256,8 @@ void grpc_oauth2_token_fetcher_credentials::on_http_response(
       new_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
           "Error occurred when fetching oauth2 token.", &error, 1);
     }
-    GRPC_CLOSURE_SCHED(pending_request->on_request_metadata, new_error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION,
+                            pending_request->on_request_metadata, new_error);
     grpc_polling_entity_del_from_pollset_set(
         pending_request->pollent, grpc_polling_entity_pollset_set(&pollent_));
     grpc_oauth2_pending_get_request_metadata* prev = pending_request;
@@ -269,9 +270,9 @@ void grpc_oauth2_token_fetcher_credentials::on_http_response(
 }
 
 bool grpc_oauth2_token_fetcher_credentials::get_request_metadata(
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
+    grpc_polling_entity* pollent, grpc_auth_metadata_context /*context*/,
     grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_error** /*error*/) {
   // Check if we can use the cached token.
   grpc_millis refresh_threshold =
       GRPC_SECURE_TOKEN_REFRESH_THRESHOLD_SECS * GPR_MS_PER_SEC;
@@ -332,8 +333,9 @@ void grpc_oauth2_token_fetcher_credentials::cancel_get_request_metadata(
         pending_requests_ = pending_request->next;
       }
       // Invoke the callback immediately with an error.
-      GRPC_CLOSURE_SCHED(pending_request->on_request_metadata,
-                         GRPC_ERROR_REF(error));
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION,
+                              pending_request->on_request_metadata,
+                              GRPC_ERROR_REF(error));
       gpr_free(pending_request);
       break;
     }
@@ -614,7 +616,7 @@ class StsTokenFetcherCredentials
       if (err != GRPC_ERROR_NONE) return cleanup();
       MaybeAddToBody(
           &body_strvec, "actor_token",
-          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(subject_token)));
+          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(actor_token)));
       MaybeAddToBody(&body_strvec, "actor_token_type", actor_token_type_.get());
     }
     return cleanup();
@@ -641,7 +643,7 @@ grpc_error* ValidateStsCredentialsOptions(
   };
   *sts_url_out = nullptr;
   InlinedVector<grpc_error*, 3> error_list;
-  UniquePtr<grpc_uri, GrpcUriDeleter> sts_url(
+  std::unique_ptr<grpc_uri, GrpcUriDeleter> sts_url(
       options->token_exchange_service_uri != nullptr
           ? grpc_uri_parse(options->token_exchange_service_uri, false)
           : nullptr);
@@ -702,15 +704,15 @@ grpc_access_token_credentials::~grpc_access_token_credentials() {
 }
 
 bool grpc_access_token_credentials::get_request_metadata(
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context /*context*/,
+    grpc_credentials_mdelem_array* md_array,
+    grpc_closure* /*on_request_metadata*/, grpc_error** /*error*/) {
   grpc_credentials_mdelem_array_add(md_array, access_token_md_);
   return true;
 }
 
 void grpc_access_token_credentials::cancel_get_request_metadata(
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_credentials_mdelem_array* /*md_array*/, grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 

data/src/core/lib/security/credentials/plugin/plugin_credentials.cc

@@ -131,7 +131,7 @@ static void plugin_md_request_metadata_ready(void* request,
   if (!r->cancelled) {
     grpc_error* error =
         process_plugin_result(r, md, num_md, status, error_details);
-    GRPC_CLOSURE_SCHED(r->on_request_metadata, error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_request_metadata, error);
   } else if (GRPC_TRACE_FLAG_ENABLED(grpc_plugin_credentials_trace)) {
     gpr_log(GPR_INFO,
             "plugin_credentials[%p]: request %p: plugin was previously "
@@ -142,7 +142,7 @@ static void plugin_md_request_metadata_ready(void* request,
 }
 
 bool grpc_plugin_credentials::get_request_metadata(
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
+    grpc_polling_entity* /*pollent*/, grpc_auth_metadata_context context,
     grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
     grpc_error** error) {
   bool retval = true;  // Synchronous return.
@@ -228,8 +228,9 @@ void grpc_plugin_credentials::cancel_get_request_metadata(
                 pending_request);
       }
       pending_request->cancelled = true;
-      GRPC_CLOSURE_SCHED(pending_request->on_request_metadata,
-                         GRPC_ERROR_REF(error));
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION,
+                              pending_request->on_request_metadata,
+                              GRPC_ERROR_REF(error));
       pending_request_remove_locked(pending_request);
       break;
     }
@@ -249,5 +250,5 @@ grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
   GRPC_API_TRACE("grpc_metadata_credentials_create_from_plugin(reserved=%p)", 1,
                  (reserved));
   GPR_ASSERT(reserved == nullptr);
-  return grpc_core::New<grpc_plugin_credentials>(plugin);
+  return new grpc_plugin_credentials(plugin);
 }

data/src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -130,7 +130,7 @@ grpc_channel_credentials* grpc_ssl_credentials_create(
       4, (pem_root_certs, pem_key_cert_pair, verify_options, reserved));
   GPR_ASSERT(reserved == nullptr);
 
-  return grpc_core::New<grpc_ssl_credentials>(
+  return new grpc_ssl_credentials(
       pem_root_certs, pem_key_cert_pair,
       reinterpret_cast<const grpc_ssl_verify_peer_options*>(verify_options));
 }
@@ -146,8 +146,8 @@ grpc_channel_credentials* grpc_ssl_credentials_create_ex(
       4, (pem_root_certs, pem_key_cert_pair, verify_options, reserved));
   GPR_ASSERT(reserved == nullptr);
 
-  return grpc_core::New<grpc_ssl_credentials>(pem_root_certs, pem_key_cert_pair,
-                                              verify_options);
+  return new grpc_ssl_credentials(pem_root_certs, pem_key_cert_pair,
+                                  verify_options);
 }
 
 //
@@ -348,7 +348,7 @@ grpc_server_credentials* grpc_ssl_server_credentials_create_with_options(
     goto done;
   }
 
-  retval = grpc_core::New<grpc_ssl_server_credentials>(*options);
+  retval = new grpc_ssl_server_credentials(*options);
 
 done:
   grpc_ssl_server_credentials_options_destroy(options);

data/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc

@@ -76,7 +76,7 @@ grpc_tls_server_authorization_check_config::
 
 /** -- Wrapper APIs declared in grpc_security.h -- **/
 grpc_tls_credentials_options* grpc_tls_credentials_options_create() {
-  return grpc_core::New<grpc_tls_credentials_options>();
+  return new grpc_tls_credentials_options();
 }
 
 int grpc_tls_credentials_options_set_cert_request_type(
@@ -133,7 +133,7 @@ int grpc_tls_credentials_options_set_server_authorization_check_config(
 }
 
 grpc_tls_key_materials_config* grpc_tls_key_materials_config_create() {
-  return grpc_core::New<grpc_tls_key_materials_config>();
+  return new grpc_tls_key_materials_config();
 }
 
 int grpc_tls_key_materials_config_set_key_materials(
@@ -192,8 +192,8 @@ grpc_tls_credential_reload_config* grpc_tls_credential_reload_config_create(
         "Schedule API is nullptr in creating TLS credential reload config.");
     return nullptr;
   }
-  return grpc_core::New<grpc_tls_credential_reload_config>(
-      config_user_data, schedule, cancel, destruct);
+  return new grpc_tls_credential_reload_config(config_user_data, schedule,
+                                               cancel, destruct);
 }
 
 grpc_tls_server_authorization_check_config*
@@ -210,6 +210,6 @@ grpc_tls_server_authorization_check_config_create(
             "check config.");
     return nullptr;
   }
-  return grpc_core::New<grpc_tls_server_authorization_check_config>(
+  return new grpc_tls_server_authorization_check_config(
       config_user_data, schedule, cancel, destruct);
 }

data/src/core/lib/security/credentials/tls/spiffe_credentials.cc

@@ -115,7 +115,7 @@ grpc_channel_credentials* grpc_tls_spiffe_credentials_create(
   if (!CredentialOptionSanityCheck(options, true /* is_client */)) {
     return nullptr;
   }
-  return grpc_core::New<SpiffeCredentials>(
+  return new SpiffeCredentials(
       grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options));
 }
 
@@ -124,6 +124,6 @@ grpc_server_credentials* grpc_tls_spiffe_server_credentials_create(
   if (!CredentialOptionSanityCheck(options, false /* is_client */)) {
     return nullptr;
   }
-  return grpc_core::New<SpiffeServerCredentials>(
+  return new SpiffeServerCredentials(
       grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options));
 }

data/src/core/lib/security/security_connector/alts/alts_security_connector.cc

@@ -36,9 +36,7 @@
 #include "src/core/tsi/alts/handshaker/alts_tsi_handshaker.h"
 #include "src/core/tsi/transport_security.h"
 
-namespace {
-
-void alts_set_rpc_protocol_versions(
+void grpc_alts_set_rpc_protocol_versions(
     grpc_gcp_rpc_protocol_versions* rpc_versions) {
   grpc_gcp_rpc_protocol_versions_set_max(rpc_versions,
                                          GRPC_PROTOCOL_VERSION_MAX_MAJOR,
@@ -48,6 +46,8 @@ void alts_set_rpc_protocol_versions(
                                          GRPC_PROTOCOL_VERSION_MIN_MINOR);
 }
 
+namespace {
+
 void alts_check_peer(tsi_peer peer,
                      grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
                      grpc_closure* on_peer_checked) {
@@ -59,7 +59,7 @@ void alts_check_peer(tsi_peer peer,
           ? GRPC_ERROR_NONE
           : GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                 "Could not get ALTS auth context from TSI peer");
-  GRPC_CLOSURE_SCHED(on_peer_checked, error);
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
 }
 
 class grpc_alts_channel_security_connector final
@@ -69,14 +69,10 @@ class grpc_alts_channel_security_connector final
       grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
       grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
       const char* target_name)
-      : grpc_channel_security_connector(/*url_scheme=*/nullptr,
+      : grpc_channel_security_connector(GRPC_ALTS_URL_SCHEME,
                                         std::move(channel_creds),
                                         std::move(request_metadata_creds)),
-        target_name_(gpr_strdup(target_name)) {
-    grpc_alts_credentials* creds =
-        static_cast<grpc_alts_credentials*>(mutable_channel_creds());
-    alts_set_rpc_protocol_versions(&creds->mutable_options()->rpc_versions);
-  }
+        target_name_(gpr_strdup(target_name)) {}
 
   ~grpc_alts_channel_security_connector() override { gpr_free(target_name_); }
 
@@ -94,7 +90,7 @@ class grpc_alts_channel_security_connector final
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
 
-  void check_peer(tsi_peer peer, grpc_endpoint* ep,
+  void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
                   grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
                   grpc_closure* on_peer_checked) override {
     alts_check_peer(peer, auth_context, on_peer_checked);
@@ -109,8 +105,8 @@ class grpc_alts_channel_security_connector final
   }
 
   bool check_call_host(grpc_core::StringView host,
-                       grpc_auth_context* auth_context,
-                       grpc_closure* on_call_host_checked,
+                       grpc_auth_context* /*auth_context*/,
+                       grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
     if (host.empty() || host != target_name_) {
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -119,7 +115,7 @@ class grpc_alts_channel_security_connector final
     return true;
   }
 
-  void cancel_check_call_host(grpc_closure* on_call_host_checked,
+  void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
                               grpc_error* error) override {
     GRPC_ERROR_UNREF(error);
   }
@@ -133,12 +129,9 @@ class grpc_alts_server_security_connector final
  public:
   grpc_alts_server_security_connector(
       grpc_core::RefCountedPtr<grpc_server_credentials> server_creds)
-      : grpc_server_security_connector(/*url_scheme=*/nullptr,
-                                       std::move(server_creds)) {
-    grpc_alts_server_credentials* creds =
-        reinterpret_cast<grpc_alts_server_credentials*>(mutable_server_creds());
-    alts_set_rpc_protocol_versions(&creds->mutable_options()->rpc_versions);
-  }
+      : grpc_server_security_connector(GRPC_ALTS_URL_SCHEME,
+                                       std::move(server_creds)) {}
+
   ~grpc_alts_server_security_connector() override = default;
 
   void add_handshakers(
@@ -154,7 +147,7 @@ class grpc_alts_server_security_connector final
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
 
-  void check_peer(tsi_peer peer, grpc_endpoint* ep,
+  void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
                   grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
                   grpc_closure* on_peer_checked) override {
     alts_check_peer(peer, auth_context, on_peer_checked);
@@ -193,7 +186,7 @@ grpc_alts_auth_context_from_tsi_peer(const tsi_peer* peer) {
     return nullptr;
   }
   grpc_gcp_rpc_protocol_versions local_versions, peer_versions;
-  alts_set_rpc_protocol_versions(&local_versions);
+  grpc_alts_set_rpc_protocol_versions(&local_versions);
   grpc_slice slice = grpc_slice_from_copied_buffer(
       rpc_versions_prop->value.data, rpc_versions_prop->value.length);
   bool decode_result =
@@ -210,6 +203,13 @@ grpc_alts_auth_context_from_tsi_peer(const tsi_peer* peer) {
     gpr_log(GPR_ERROR, "Mismatch of local and peer rpc protocol versions.");
     return nullptr;
   }
+  /* Validate ALTS Context. */
+  const tsi_peer_property* alts_context_prop =
+      tsi_peer_get_property_by_name(peer, TSI_ALTS_CONTEXT);
+  if (alts_context_prop == nullptr) {
+    gpr_log(GPR_ERROR, "Missing alts context property.");
+    return nullptr;
+  }
   /* Create auth context. */
   auto ctx = grpc_core::MakeRefCounted<grpc_auth_context>(nullptr);
   grpc_auth_context_add_cstring_property(
@@ -226,6 +226,12 @@ grpc_alts_auth_context_from_tsi_peer(const tsi_peer* peer) {
       GPR_ASSERT(grpc_auth_context_set_peer_identity_property_name(
                      ctx.get(), TSI_ALTS_SERVICE_ACCOUNT_PEER_PROPERTY) == 1);
     }
+    /* Add alts context to auth context. */
+    if (strcmp(tsi_prop->name, TSI_ALTS_CONTEXT) == 0) {
+      grpc_auth_context_add_property(ctx.get(), TSI_ALTS_CONTEXT,
+                                     tsi_prop->value.data,
+                                     tsi_prop->value.length);
+    }
   }
   if (!grpc_auth_context_peer_is_authenticated(ctx.get())) {
     gpr_log(GPR_ERROR, "Invalid unauthenticated peer.");