grpc 1.75.0 → 1.78.1

data/src/core/handshaker/http_connect/http_connect_handshaker.cc

@@ -30,11 +30,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_factory.h"
@@ -53,6 +48,11 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/http_connect/http_proxy_mapper.cc

@@ -29,7 +29,17 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
+#include "src/core/handshaker/http_connect/http_connect_handshaker.h"
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/util/env.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/host_port.h"
+#include "src/core/util/memory.h"
+#include "src/core/util/string.h"
+#include "src/core/util/uri.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -41,16 +51,6 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "src/core/handshaker/http_connect/http_connect_handshaker.h"
-#include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/util/env.h"
-#include "src/core/util/host_port.h"
-#include "src/core/util/memory.h"
-#include "src/core/util/string.h"
-#include "src/core/util/uri.h"
 
 namespace grpc_core {
 namespace {
@@ -105,7 +105,7 @@ bool AddressIncluded(const std::optional<grpc_resolved_address>& target_address,
 ///
 std::optional<std::string> GetHttpProxyServer(
     const ChannelArgs& args, std::optional<std::string>* user_cred) {
-  CHECK_NE(user_cred, nullptr);
+  GRPC_CHECK_NE(user_cred, nullptr);
   absl::StatusOr<URI> uri;
   // We check the following places to determine the HTTP proxy to use, stopping
   // at the first one that is set:

data/src/core/handshaker/http_connect/http_proxy_mapper.h

@@ -24,11 +24,11 @@
 #include <optional>
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/http_connect/xds_http_proxy_mapper.cc

@@ -20,12 +20,12 @@
 #include <optional>
 #include <string>
 
-#include "absl/log/log.h"
 #include "src/core/handshaker/http_connect/http_connect_handshaker.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/xds/grpc/xds_endpoint.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/http_connect/xds_http_proxy_mapper.h

@@ -20,11 +20,11 @@
 #include <optional>
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/proxy_mapper.h

@@ -24,9 +24,9 @@
 #include <optional>
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/proxy_mapper_registry.h

@@ -27,10 +27,10 @@
 #include <string>
 #include <vector>
 
-#include "absl/strings/string_view.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/security/legacy_secure_endpoint.cc

@@ -32,11 +32,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/handshaker/security/secure_endpoint.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -53,10 +48,15 @@
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 #define STAGING_BUFFER_SIZE 8192
 
@@ -367,7 +367,7 @@ static void endpoint_read(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
   SECURE_ENDPOINT_REF(ep, "read");
   if (ep->leftover_bytes.count) {
     grpc_slice_buffer_swap(&ep->leftover_bytes, &ep->source_buffer);
-    CHECK_EQ(ep->leftover_bytes.count, 0u);
+    GRPC_CHECK_EQ(ep->leftover_bytes.count, 0u);
     on_read(ep, absl::OkStatus());
     return;
   }

data/src/core/handshaker/security/pipelined_secure_endpoint.cc

@@ -34,14 +34,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 #include "src/core/handshaker/security/secure_endpoint.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -56,12 +48,20 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/tsi/transport_security_interface.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 #define STAGING_BUFFER_SIZE 8192
 
@@ -98,6 +98,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
       write_staging_buffer_ =
           memory_owner_.MakeSlice(MemoryRequest(STAGING_BUFFER_SIZE));
     }
+    is_zero_copy_protector_ = zero_copy_protector_ != nullptr;
   }
 
   ~FrameProtector() override {
@@ -180,6 +181,8 @@ class FrameProtector : public RefCounted<FrameProtector> {
     read_buffer_ = nullptr;
   }
 
+  bool IsZeroCopyProtector() const { return is_zero_copy_protector_; }
+
   absl::Status Unprotect(absl::Status read_status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(read_mu_) {
     if (shutdown_) {
@@ -451,6 +454,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
   int min_progress_size_ = 1;
   SliceBuffer protector_staging_buffer_;
   bool shutdown_ = false;
+  bool is_zero_copy_protector_ = false;
 };
 }  // namespace
 }  // namespace grpc_core
@@ -597,15 +601,17 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
         // called again once that read completes.
         if (unprotecting_.value()) {
           lock.Release();
-          event_engine_->Run(
-              [impl = Ref()]() mutable { ContinueUnprotect(std::move(impl)); });
+          event_engine_->Run([impl = Ref()]() mutable {
+            grpc_core::ExecCtx exec_ctx;
+            ContinueUnprotect(std::move(impl));
+          });
         }
         return true;
       }
 
       // If we're already unprotecting on another thread, we need to store the
       // buffer until we have some unprotected bytes to give it.
-      CHECK(on_read_ == nullptr);
+      GRPC_CHECK(on_read_ == nullptr);
       pending_output_buffer_ = buffer;
       on_read_ = std::move(on_read);
       last_read_args_ = std::move(args);
@@ -672,8 +678,8 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
     void StartFirstRead() ABSL_LOCKS_EXCLUDED(read_queue_mu_) {
       grpc_core::ReleasableMutexLock lock(&read_queue_mu_);
       unprotecting_ = true;
-      CHECK(protected_data_buffer_ == nullptr);
-      CHECK(unprotected_data_buffer_ == nullptr);
+      GRPC_CHECK(protected_data_buffer_ == nullptr);
+      GRPC_CHECK(unprotected_data_buffer_ == nullptr);
       // First, check if there are any leftover bytes to unprotect. If there
       // are, we can immediately start unprotecting those bytes.
       if (frame_protector_.MaybeReadLeftoverBytes(
@@ -690,6 +696,7 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
       args.set_read_hint_bytes(frame_protector_.min_progress_size());
       lock.Release();
       event_engine_->Run([impl = Ref(), args = std::move(args)]() mutable {
+        grpc_core::ExecCtx exec_ctx;
         // If the endpoint closed whilst waiting for this callback, then
         // fail out the read and we're done.
         grpc_core::ReleasableMutexLock lock(impl->frame_protector_.read_mu());
@@ -701,6 +708,7 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
         }
         const bool read_finished_immediately = impl->wrapped_ep_->Read(
             [impl = impl->Ref()](absl::Status status) mutable {
+              grpc_core::ExecCtx exec_ctx;
               FinishFirstRead(std::move(impl), status);
             },
             impl->staging_protected_data_buffer_.get(), std::move(args));
@@ -803,20 +811,34 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
           impl->frame_protector_.TraceOp("data",
                                          source_buffer->c_slice_buffer());
           args = std::move(impl->last_read_args_);
-          args.set_read_hint_bytes(impl->frame_protector_.min_progress_size());
+          if (impl->frame_protector_.IsZeroCopyProtector()) {
+            // We currently only track min progress size for zero copy
+            // protectors. Once we add this for non-zero copy protectors, we
+            // should remove the if condition.
+            // Since we start unprotecting after the first read, the min
+            // progress size does not account for the bytes we have already read
+            // in the previous read, so we need to subtract them here.
+            args.set_read_hint_bytes(
+                std::max<size_t>(1, impl->frame_protector_.min_progress_size() -
+                                        source_buffer->Length()));
+          } else if (args.read_hint_bytes() > 0) {
+            args.set_read_hint_bytes(std::max<size_t>(
+                1, args.read_hint_bytes() - source_buffer->Length()));
+          }
         }
 
         // Kick off the next read in another thread while we unprotect in this
         // thread.
         impl->event_engine_->Run(
             [impl = impl->Ref(), args = std::move(args)]() mutable {
+              grpc_core::ExecCtx exec_ctx;
               StartAsyncRead(std::move(impl), std::move(args));
             });
 
         {
           grpc_core::ReleasableMutexLock lock(impl->frame_protector_.read_mu());
           // Unprotect the bytes.
-          CHECK(read_buffer == nullptr);
+          GRPC_CHECK(read_buffer == nullptr);
           impl->frame_protector_.SetSourceBuffer(std::move(source_buffer));
           read_buffer = std::make_unique<SliceBuffer>();
           impl->frame_protector_.BeginRead(read_buffer->c_slice_buffer());
@@ -864,6 +886,7 @@ class PipelinedSecureEndpoint final : public EventEngine::Endpoint {
       }
       const bool read_finished_immediately = impl->wrapped_ep_->Read(
           [impl = impl->Ref()](absl::Status status) mutable {
+            grpc_core::ExecCtx exec_ctx;
             FinishAsyncRead(std::move(impl), status);
           },
           impl->staging_protected_data_buffer_.get(), std::move(args));

data/src/core/handshaker/security/secure_endpoint.cc

@@ -37,12 +37,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -59,10 +53,16 @@
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 #define STAGING_BUFFER_SIZE 8192
 
@@ -71,6 +71,12 @@ static void on_write(void* user_data, grpc_error_handle error);
 
 namespace grpc_core {
 namespace {
+
+grpc_slice AllocSlice(size_t size, void* user_data) {
+  auto* owner = static_cast<MemoryOwner*>(user_data);
+  return owner->MakeSlice(MemoryRequest(size));
+}
+
 class FrameProtector : public RefCounted<FrameProtector> {
  public:
   FrameProtector(tsi_frame_protector* protector,
@@ -94,6 +100,10 @@ class FrameProtector : public RefCounted<FrameProtector> {
       }
     }
     if (zero_copy_protector_ != nullptr) {
+      if (IsTrackZeroCopyAllocationsInResourceQuotaEnabled()) {
+        tsi_zero_copy_grpc_protector_set_allocator(zero_copy_protector_,
+                                                   &AllocSlice, &memory_owner_);
+      }
       read_staging_buffer_ = grpc_empty_slice();
       write_staging_buffer_ = grpc_empty_slice();
     } else {
@@ -102,6 +112,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
       write_staging_buffer_ =
           memory_owner_.MakeSlice(MemoryRequest(STAGING_BUFFER_SIZE));
     }
+    is_zero_copy_protector_ = (zero_copy_protector_ != nullptr);
   }
 
   ~FrameProtector() override {
@@ -289,6 +300,8 @@ class FrameProtector : public RefCounted<FrameProtector> {
     grpc_slice_buffer_reset_and_unref(read_buffer_);
   }
 
+  bool IsZeroCopyProtector() const { return is_zero_copy_protector_; }
+
   bool MaybeCompleteReadImmediately() {
     GRPC_TRACE_LOG(secure_endpoint, INFO)
         << "MaybeCompleteReadImmediately: " << this
@@ -456,6 +469,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
   int min_progress_size_ = 1;
   SliceBuffer protector_staging_buffer_;
   bool shutdown_ = false;
+  bool is_zero_copy_protector_ = false;
 };
 }  // namespace
 }  // namespace grpc_core
@@ -795,9 +809,12 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       if (frame_protector_.MaybeCompleteReadImmediately()) {
         return MaybeFinishReadImmediately();
       }
-      args.set_read_hint_bytes(frame_protector_.min_progress_size());
+      if (frame_protector_.IsZeroCopyProtector()) {
+        args.set_read_hint_bytes(frame_protector_.min_progress_size());
+      }
       bool read_completed_immediately = wrapped_ep_->Read(
           [impl = Ref()](absl::Status status) mutable {
+            grpc_core::ExecCtx exec_ctx;
             FinishAsyncRead(std::move(impl), std::move(status));
           },
           frame_protector_.source_buffer(), std::move(args));
@@ -832,7 +849,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           // in the FinishAsyncWrites path, and EventEngine insists that one
           // write finishes before a second begins, we should never see a Write
           // call here with a non-null pending_writes_.
-          CHECK(pending_writes_ == nullptr);
+          GRPC_CHECK(pending_writes_ == nullptr);
           pending_writes_ = std::make_unique<SliceBuffer>(std::move(*data));
           frame_protector_.TraceOp("Pending",
                                    pending_writes_->c_slice_buffer());
@@ -844,6 +861,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           if (!*writing_) {
             writing_ = true;
             event_engine_->Run([impl = Ref()]() mutable {
+              grpc_core::ExecCtx exec_ctx;
               FinishAsyncWrite(std::move(impl));
             });
           }
@@ -917,6 +935,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       if (grpc_core::IsSecureEndpointOffloadLargeReadsEnabled() &&
           frame_protector_.source_buffer()->Length() > large_read_threshold_) {
         event_engine_->Run([impl = Ref()]() mutable {
+          grpc_core::ExecCtx exec_ctx;
           FinishAsyncRead(std::move(impl), absl::OkStatus());
         });
         return false;
@@ -982,7 +1001,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           grpc_core::ReleasableMutexLock lock(&impl->write_queue_mu_);
           if (impl->pending_writes_ == nullptr) {
             impl->writing_ = false;
-            DCHECK(impl->on_write_ == nullptr);
+            GRPC_DCHECK(impl->on_write_ == nullptr);
             lock.Release();
             return;
           }
@@ -990,7 +1009,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           data = std::move(impl->pending_writes_);
           impl->frame_protector_.TraceOp("data", data->c_slice_buffer());
           args = std::move(impl->last_write_args_);
-          DCHECK(impl->on_write_ != nullptr);
+          GRPC_DCHECK(impl->on_write_ != nullptr);
         }
         impl->event_engine_->Run(
             [on_write = std::move(impl->on_write_)]() mutable {
@@ -1022,6 +1041,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
         // immediately, in which case we'll loop.
         const bool write_finished_immediately = impl->wrapped_ep_->Write(
             [impl](absl::Status status) mutable {
+              grpc_core::ExecCtx exec_ctx;
               // Async completion path: if we completed successfully then loop
               // back into FinishAsyncWrite to see if there's more writing to
               // do.
@@ -1075,7 +1095,7 @@ grpc_core::OrphanablePtr<grpc_endpoint> grpc_secure_endpoint_create(
     std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
         event_engine_endpoint = grpc_event_engine::experimental::
             grpc_take_wrapped_event_engine_endpoint(to_wrap.release());
-    CHECK(event_engine_endpoint != nullptr);
+    GRPC_CHECK(event_engine_endpoint != nullptr);
     if (grpc_core::IsPipelinedReadSecureEndpointEnabled()) {
       return grpc_pipelined_secure_endpoint_create(
           protector, zero_copy_protector, std::move(event_engine_endpoint),

data/src/core/handshaker/security/security_handshaker.cc

@@ -35,12 +35,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/attributes.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
@@ -61,9 +55,15 @@
 #include "src/core/transport/auth_context.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/base/attributes.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 #define GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE 256
 
@@ -324,6 +324,9 @@ grpc_error_handle SecurityHandshaker::CheckPeerLocked() {
       });
   connector_->check_peer(peer, args_->endpoint.get(), args_->args,
                          &auth_context_, on_peer_checked_);
+  if (auth_context_ != nullptr) {
+    auth_context_->set_protocol(connector_->type().name());
+  }
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       auth_context_.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
@@ -345,7 +348,7 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
   }
   // Read more if we need to.
   if (result == TSI_INCOMPLETE_DATA) {
-    CHECK_EQ(bytes_to_send_size, 0u);
+    GRPC_CHECK_EQ(bytes_to_send_size, 0u);
     grpc_endpoint_read(
         args_->endpoint.get(), args_->read_buffer.c_slice_buffer(),
         NewClosure([self = RefAsSubclass<SecurityHandshaker>()](
@@ -365,7 +368,7 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
   }
   // Update handshaker result.
   if (handshaker_result != nullptr) {
-    CHECK_EQ(handshaker_result_, nullptr);
+    GRPC_CHECK_EQ(handshaker_result_, nullptr);
     handshaker_result_ = handshaker_result;
   }
   if (bytes_to_send_size > 0) {

data/src/core/handshaker/security/security_handshaker.h

@@ -22,13 +22,13 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/security_connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -27,11 +27,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_factory.h"
@@ -50,9 +45,14 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/uri.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 
@@ -185,7 +185,7 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       }
       return;
     }
-    CHECK_NE(self->endpoint_to_destroy_, nullptr);
+    GRPC_CHECK_NE(self->endpoint_to_destroy_, nullptr);
     self->args_->endpoint.reset(self->endpoint_to_destroy_);
     self->endpoint_to_destroy_ = nullptr;
     if (self->bind_endpoint_to_pollset_) {

data/src/core/lib/address_utils/parse_address.cc

@@ -41,17 +41,17 @@
 #endif  // GRPC_HAVE_UNIX_SOCKET
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/strip.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/util/grpc_if_nametoindex.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/string.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
 
 // IWYU pragma: no_include <arpa/inet.h>
 

data/src/core/lib/address_utils/parse_address.h

@@ -22,11 +22,11 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/uri.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 /// Populate \a resolved_addr from \a uri, whose path is expected to contain a
 /// unix socket path. Returns true upon success.

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -31,16 +31,16 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/uri.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #ifdef GPR_WINDOWS

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -24,8 +24,8 @@
 
 #include <string>
 
-#include "absl/status/statusor.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "absl/status/statusor.h"
 
 // Returns true if addr is an IPv4-mapped IPv6 address within the
 // ::ffff:0.0.0.0/96 range, or false otherwise.