grpc 1.63.2 → 1.64.0.pre1

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

@@ -14,29 +14,30 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h"
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 void grpc_tls_certificate_distributor::SetKeyMaterials(
     const std::string& cert_name, absl::optional<std::string> pem_root_certs,
     absl::optional<grpc_core::PemKeyCertPairList> pem_key_cert_pairs) {
-  GPR_ASSERT(pem_root_certs.has_value() || pem_key_cert_pairs.has_value());
+  CHECK(pem_root_certs.has_value() || pem_key_cert_pairs.has_value());
   grpc_core::MutexLock lock(&mu_);
   auto& cert_info = certificate_info_map_[cert_name];
   if (pem_root_certs.has_value()) {
     // Successful credential updates will clear any pre-existing error.
     cert_info.SetRootError(absl::OkStatus());
     for (auto* watcher_ptr : cert_info.root_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
+      CHECK_NE(watcher_ptr, nullptr);
       const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      GPR_ASSERT(watcher_it->second.root_cert_name.has_value());
+      CHECK(watcher_it != watchers_.end());
+      CHECK(watcher_it->second.root_cert_name.has_value());
       absl::optional<grpc_core::PemKeyCertPairList>
           pem_key_cert_pairs_to_report;
       if (pem_key_cert_pairs.has_value() &&
@@ -58,10 +59,10 @@ void grpc_tls_certificate_distributor::SetKeyMaterials(
     // Successful credential updates will clear any pre-existing error.
     cert_info.SetIdentityError(absl::OkStatus());
     for (const auto watcher_ptr : cert_info.identity_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
+      CHECK_NE(watcher_ptr, nullptr);
       const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      GPR_ASSERT(watcher_it->second.identity_cert_name.has_value());
+      CHECK(watcher_it != watchers_.end());
+      CHECK(watcher_it->second.identity_cert_name.has_value());
       absl::optional<absl::string_view> pem_root_certs_to_report;
       if (pem_root_certs.has_value() &&
           watcher_it->second.root_cert_name == cert_name) {
@@ -102,14 +103,14 @@ void grpc_tls_certificate_distributor::SetErrorForCert(
     const std::string& cert_name,
     absl::optional<grpc_error_handle> root_cert_error,
     absl::optional<grpc_error_handle> identity_cert_error) {
-  GPR_ASSERT(root_cert_error.has_value() || identity_cert_error.has_value());
+  CHECK(root_cert_error.has_value() || identity_cert_error.has_value());
   grpc_core::MutexLock lock(&mu_);
   CertificateInfo& cert_info = certificate_info_map_[cert_name];
   if (root_cert_error.has_value()) {
     for (auto* watcher_ptr : cert_info.root_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
+      CHECK_NE(watcher_ptr, nullptr);
       const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
+      CHECK(watcher_it != watchers_.end());
       // identity_cert_error_to_report is the error of the identity cert this
       // watcher is watching, if there is any.
       grpc_error_handle identity_cert_error_to_report;
@@ -127,9 +128,9 @@ void grpc_tls_certificate_distributor::SetErrorForCert(
   }
   if (identity_cert_error.has_value()) {
     for (auto* watcher_ptr : cert_info.identity_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
+      CHECK_NE(watcher_ptr, nullptr);
       const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
+      CHECK(watcher_it != watchers_.end());
       // root_cert_error_to_report is the error of the root cert this watcher is
       // watching, if there is any.
       grpc_error_handle root_cert_error_to_report;
@@ -150,11 +151,11 @@ void grpc_tls_certificate_distributor::SetErrorForCert(
 };
 
 void grpc_tls_certificate_distributor::SetError(grpc_error_handle error) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   grpc_core::MutexLock lock(&mu_);
   for (const auto& watcher : watchers_) {
     const auto watcher_ptr = watcher.first;
-    GPR_ASSERT(watcher_ptr != nullptr);
+    CHECK_NE(watcher_ptr, nullptr);
     const auto& watcher_info = watcher.second;
     watcher_ptr->OnError(
         watcher_info.root_cert_name.has_value() ? error : absl::OkStatus(),
@@ -175,16 +176,16 @@ void grpc_tls_certificate_distributor::WatchTlsCertificates(
   bool already_watching_identity_for_root_cert = false;
   bool start_watching_identity_cert = false;
   bool already_watching_root_for_identity_cert = false;
-  GPR_ASSERT(root_cert_name.has_value() || identity_cert_name.has_value());
+  CHECK(root_cert_name.has_value() || identity_cert_name.has_value());
   TlsCertificatesWatcherInterface* watcher_ptr = watcher.get();
-  GPR_ASSERT(watcher_ptr != nullptr);
+  CHECK_NE(watcher_ptr, nullptr);
   // Update watchers_ and certificate_info_map_.
   {
     grpc_core::MutexLock lock(&mu_);
     const auto watcher_it = watchers_.find(watcher_ptr);
     // The caller needs to cancel the watcher first if it wants to re-register
     // the watcher.
-    GPR_ASSERT(watcher_it == watchers_.end());
+    CHECK(watcher_it == watchers_.end());
     watchers_[watcher_ptr] = {std::move(watcher), root_cert_name,
                               identity_cert_name};
     absl::optional<absl::string_view> updated_root_certs;
@@ -270,7 +271,7 @@ void grpc_tls_certificate_distributor::CancelTlsCertificatesWatch(
     watchers_.erase(it);
     if (root_cert_name.has_value()) {
       auto it = certificate_info_map_.find(*root_cert_name);
-      GPR_ASSERT(it != certificate_info_map_.end());
+      CHECK(it != certificate_info_map_.end());
       CertificateInfo& cert_info = it->second;
       cert_info.root_cert_watchers.erase(watcher);
       stop_watching_root_cert = cert_info.root_cert_watchers.empty();
@@ -282,7 +283,7 @@ void grpc_tls_certificate_distributor::CancelTlsCertificatesWatch(
     }
     if (identity_cert_name.has_value()) {
       auto it = certificate_info_map_.find(*identity_cert_name);
-      GPR_ASSERT(it != certificate_info_map_.end());
+      CHECK(it != certificate_info_map_.end());
       CertificateInfo& cert_info = it->second;
       cert_info.identity_cert_watchers.erase(watcher);
       stop_watching_identity_cert = cert_info.identity_cert_watchers.empty();
@@ -326,13 +327,13 @@ grpc_tls_identity_pairs* grpc_tls_identity_pairs_create() {
 void grpc_tls_identity_pairs_add_pair(grpc_tls_identity_pairs* pairs,
                                       const char* private_key,
                                       const char* cert_chain) {
-  GPR_ASSERT(pairs != nullptr);
-  GPR_ASSERT(private_key != nullptr);
-  GPR_ASSERT(cert_chain != nullptr);
+  CHECK_NE(pairs, nullptr);
+  CHECK_NE(private_key, nullptr);
+  CHECK_NE(cert_chain, nullptr);
   pairs->pem_key_cert_pairs.emplace_back(private_key, cert_chain);
 }
 
 void grpc_tls_identity_pairs_destroy(grpc_tls_identity_pairs* pairs) {
-  GPR_ASSERT(pairs != nullptr);
+  CHECK_NE(pairs, nullptr);
   delete pairs;
 }

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

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <map>
 #include <memory>
@@ -30,6 +28,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <openssl/bio.h>
 #include <openssl/crypto.h>
 #include <openssl/evp.h>
@@ -26,6 +24,8 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 namespace grpc_core {

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 #include <stdint.h>
@@ -25,10 +23,13 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 
+#include <grpc/credentials.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -128,15 +129,15 @@ FileWatcherCertificateProvider::FileWatcherCertificateProvider(
     refresh_interval_sec_ = kMinimumFileWatcherRefreshIntervalSeconds;
   }
   // Private key and identity cert files must be both set or both unset.
-  GPR_ASSERT(private_key_path_.empty() == identity_certificate_path_.empty());
+  CHECK(private_key_path_.empty() == identity_certificate_path_.empty());
   // Must be watching either root or identity certs.
-  GPR_ASSERT(!private_key_path_.empty() || !root_cert_path_.empty());
+  CHECK(!private_key_path_.empty() || !root_cert_path_.empty());
   gpr_event_init(&shutdown_event_);
   ForceUpdate();
   auto thread_lambda = [](void* arg) {
     FileWatcherCertificateProvider* provider =
         static_cast<FileWatcherCertificateProvider*>(arg);
-    GPR_ASSERT(provider != nullptr);
+    CHECK_NE(provider, nullptr);
     while (true) {
       void* value = gpr_event_wait(
           &provider->shutdown_event_,
@@ -386,7 +387,7 @@ int64_t FileWatcherCertificateProvider::TestOnlyGetRefreshIntervalSecond()
 
 grpc_tls_certificate_provider* grpc_tls_certificate_provider_static_data_create(
     const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs) {
-  GPR_ASSERT(root_certificate != nullptr || pem_key_cert_pairs != nullptr);
+  CHECK(root_certificate != nullptr || pem_key_cert_pairs != nullptr);
   grpc_core::ExecCtx exec_ctx;
   grpc_core::PemKeyCertPairList identity_pairs_core;
   if (pem_key_cert_pairs != nullptr) {

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

@@ -17,20 +17,20 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_PROVIDER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_PROVIDER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <map>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gpr/useful.h"
@@ -66,7 +66,7 @@ struct grpc_tls_certificate_provider
   // be reused when two different `grpc_tls_certificate_provider` objects are
   // used but they compare as equal (assuming other channel args match).
   int Compare(const grpc_tls_certificate_provider* other) const {
-    GPR_ASSERT(other != nullptr);
+    CHECK_NE(other, nullptr);
     int r = type().Compare(other->type());
     if (r != 0) return r;
     return CompareImpl(other);

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h"
 
 #include <string.h>
@@ -23,10 +21,12 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -112,7 +112,7 @@ UniqueTypeName NoOpCertificateVerifier::type() const {
 bool HostNameCertificateVerifier::Verify(
     grpc_tls_custom_verification_check_request* request,
     std::function<void(absl::Status)>, absl::Status* sync_status) {
-  GPR_ASSERT(request != nullptr);
+  CHECK_NE(request, nullptr);
   // Extract the target name, and remove its port.
   const char* target_name = request->target_name;
   if (target_name == nullptr) {

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

@@ -17,17 +17,18 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_VERIFIER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_VERIFIER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <map>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -58,7 +59,7 @@ struct grpc_tls_certificate_verifier
   // If this method returns 0, it means that gRPC can treat the two certificate
   // verifiers as effectively the same.
   int Compare(const grpc_tls_certificate_verifier* other) const {
-    GPR_ASSERT(other != nullptr);
+    CHECK_NE(other, nullptr);
     int r = type().Compare(other->type());
     if (r != 0) return r;
     return CompareImpl(other);

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

@@ -16,14 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
 
 #include <memory>
 
+#include "absl/log/check.h"
+
 #include <grpc/grpc_crl_provider.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -40,7 +41,7 @@ grpc_tls_credentials_options* grpc_tls_credentials_options_create() {
 
 grpc_tls_credentials_options* grpc_tls_credentials_options_copy(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   return new grpc_tls_credentials_options(*options);
 }
 
@@ -52,21 +53,21 @@ void grpc_tls_credentials_options_destroy(
 void grpc_tls_credentials_options_set_cert_request_type(
     grpc_tls_credentials_options* options,
     grpc_ssl_client_certificate_request_type type) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_cert_request_type(type);
 }
 
 void grpc_tls_credentials_options_set_verify_server_cert(
     grpc_tls_credentials_options* options, int verify_server_cert) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_verify_server_cert(verify_server_cert);
 }
 
 void grpc_tls_credentials_options_set_certificate_provider(
     grpc_tls_credentials_options* options,
     grpc_tls_certificate_provider* provider) {
-  GPR_ASSERT(options != nullptr);
-  GPR_ASSERT(provider != nullptr);
+  CHECK_NE(options, nullptr);
+  CHECK_NE(provider, nullptr);
   grpc_core::ExecCtx exec_ctx;
   options->set_certificate_provider(
       provider->Ref(DEBUG_LOCATION, "set_certificate_provider"));
@@ -74,45 +75,45 @@ void grpc_tls_credentials_options_set_certificate_provider(
 
 void grpc_tls_credentials_options_watch_root_certs(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_watch_root_cert(true);
 }
 
 void grpc_tls_credentials_options_set_root_cert_name(
     grpc_tls_credentials_options* options, const char* root_cert_name) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_root_cert_name(root_cert_name);
 }
 
 void grpc_tls_credentials_options_watch_identity_key_cert_pairs(
     grpc_tls_credentials_options* options) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_watch_identity_pair(true);
 }
 
 void grpc_tls_credentials_options_set_identity_cert_name(
     grpc_tls_credentials_options* options, const char* identity_cert_name) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_identity_cert_name(identity_cert_name);
 }
 
 void grpc_tls_credentials_options_set_certificate_verifier(
     grpc_tls_credentials_options* options,
     grpc_tls_certificate_verifier* verifier) {
-  GPR_ASSERT(options != nullptr);
-  GPR_ASSERT(verifier != nullptr);
+  CHECK_NE(options, nullptr);
+  CHECK_NE(verifier, nullptr);
   options->set_certificate_verifier(verifier->Ref());
 }
 
 void grpc_tls_credentials_options_set_crl_directory(
     grpc_tls_credentials_options* options, const char* crl_directory) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_crl_directory(crl_directory);
 }
 
 void grpc_tls_credentials_options_set_check_call_host(
     grpc_tls_credentials_options* options, int check_call_host) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_check_call_host(check_call_host);
 }
 
@@ -146,18 +147,18 @@ void grpc_tls_credentials_options_set_send_client_ca_list(
 void grpc_tls_credentials_options_set_crl_provider(
     grpc_tls_credentials_options* options,
     std::shared_ptr<grpc_core::experimental::CrlProvider> provider) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_crl_provider(provider);
 }
 
 void grpc_tls_credentials_options_set_min_tls_version(
     grpc_tls_credentials_options* options, grpc_tls_version min_tls_version) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_min_tls_version(min_tls_version);
 }
 
 void grpc_tls_credentials_options_set_max_tls_version(
     grpc_tls_credentials_options* options, grpc_tls_version max_tls_version) {
-  GPR_ASSERT(options != nullptr);
+  CHECK_NE(options, nullptr);
   options->set_max_tls_version(max_tls_version);
 }

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

@@ -25,6 +25,7 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"

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

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/grpc_tls_crl_provider.h"
 
 #include <limits.h>
 
+#include <grpc/support/port_platform.h>
+
 // IWYU pragma: no_include <ratio>
 #include <memory>
 #include <type_traits>

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CRL_PROVIDER_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CRL_PROVIDER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <chrono>
 #include <functional>
 #include <memory>
@@ -39,6 +37,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc_crl_provider.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/directory_reader.h"
 #include "src/core/lib/gprpp/sync.h"

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/tls_credentials.h"
 
 #include <memory>
@@ -30,6 +28,7 @@
 #include <grpc/grpc_security_constants.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"

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

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
 
-#include <grpc/support/port_platform.h>
-
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
 
 #include <stddef.h>
@@ -29,6 +27,7 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

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

@@ -19,14 +19,13 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_UTILS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

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

@@ -16,17 +16,16 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
 
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_security_constants.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/xds_certificate_provider.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
@@ -34,6 +33,7 @@
 #include "src/core/lib/security/credentials/tls/tls_credentials.h"
 #include "src/core/lib/security/credentials/tls/tls_utils.h"
 #include "src/core/load_balancing/xds/xds_channel_args.h"
+#include "src/core/xds/grpc/xds_certificate_provider.h"
 
 namespace grpc_core {
 
@@ -80,7 +80,7 @@ XdsCertificateVerifier::XdsCertificateVerifier(
 bool XdsCertificateVerifier::Verify(
     grpc_tls_custom_verification_check_request* request,
     std::function<void(absl::Status)>, absl::Status* sync_status) {
-  GPR_ASSERT(request != nullptr);
+  CHECK_NE(request, nullptr);
   if (!XdsVerifySubjectAlternativeNames(
           request->peer_info.san_names.uri_names,
           request->peer_info.san_names.uri_names_size,
@@ -166,7 +166,7 @@ XdsCredentials::create_security_connector(
                                                         target_name, args);
     }
   }
-  GPR_ASSERT(fallback_credentials_ != nullptr);
+  CHECK(fallback_credentials_ != nullptr);
   return fallback_credentials_->create_security_connector(std::move(call_creds),
                                                           target_name, args);
 }
@@ -217,12 +217,12 @@ UniqueTypeName XdsServerCredentials::Type() {
 
 grpc_channel_credentials* grpc_xds_credentials_create(
     grpc_channel_credentials* fallback_credentials) {
-  GPR_ASSERT(fallback_credentials != nullptr);
+  CHECK_NE(fallback_credentials, nullptr);
   return new grpc_core::XdsCredentials(fallback_credentials->Ref());
 }
 
 grpc_server_credentials* grpc_xds_server_credentials_create(
     grpc_server_credentials* fallback_credentials) {
-  GPR_ASSERT(fallback_credentials != nullptr);
+  CHECK_NE(fallback_credentials, nullptr);
   return new grpc_core::XdsServerCredentials(fallback_credentials->Ref());
 }

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H
 #define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <functional>
@@ -30,10 +28,11 @@
 
 #include "absl/status/status.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/xds/xds_certificate_provider.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
@@ -41,6 +40,7 @@
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_verifier.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
+#include "src/core/xds/grpc/xds_certificate_provider.h"
 
 namespace grpc_core {