grpc 1.68.1 → 1.69.0.pre1

data/src/core/lib/surface/connection_context.h

@@ -0,0 +1,156 @@
+//
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_SURFACE_CONNECTION_CONTEXT_H
+#define GRPC_SRC_CORE_LIB_SURFACE_CONNECTION_CONTEXT_H
+
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "src/core/util/no_destruct.h"
+#include "src/core/util/orphanable.h"
+
+namespace grpc_core {
+
+class ConnectionContext;
+
+template <typename T>
+struct ConnectionContextProperty;
+
+namespace connection_context_detail {
+
+// Tracks all registered/known auth property types (these should only be
+// registered via AuthPropertyTraits at static initialization time).
+class BaseConnectionContextPropertiesTraits {
+ public:
+  // Count of number of registered auth context properties.
+  static uint16_t NumProperties() {
+    return static_cast<uint16_t>(RegisteredTraits().size());
+  }
+
+  // Number of bytes required to store pointers of all registered auth context
+  // properties.
+  static size_t Size() { return NumProperties() * sizeof(void*); }
+
+  // Call the registered destruction function for a context.
+  static void Destroy(uint16_t id, void* ptr) {
+    if (ptr == nullptr) return;
+    RegisteredTraits()[id](ptr);
+  }
+
+  // Allocate a new context id and register the destruction function.
+  template <typename T>
+  static uint16_t AllocateId(void (*destroy)(void* ptr)) {
+    auto& traits = RegisteredTraits();
+    const uint16_t id = static_cast<uint16_t>(traits.size());
+    traits.push_back(destroy);
+    return id;
+  }
+
+ private:
+  // Allocate a new context id and register the destruction function.
+
+  static std::vector<void (*)(void*)>& RegisteredTraits() {
+    static NoDestruct<std::vector<void (*)(void*)>> registered_traits;
+    return *registered_traits;
+  }
+};
+
+template <typename T>
+class ConnectionContextPropertiesTraits
+    : public BaseConnectionContextPropertiesTraits {
+ public:
+  static uint16_t id() { return id_; }
+  template <typename... Args>
+  static T* Construct(Args&&... args) {
+    return new T(std::forward<Args>(args)...);
+  }
+  static void Destruct(void* p) { delete reinterpret_cast<T*>(p); }
+
+ protected:
+  static const uint16_t id_;
+};
+
+template <typename T>
+const uint16_t ConnectionContextPropertiesTraits<T>::id_ =
+    BaseConnectionContextPropertiesTraits::AllocateId<T>(
+        ConnectionContextPropertiesTraits<T>::Destruct);
+
+}  // namespace connection_context_detail
+
+class ConnectionContext final : public Orphanable {
+ public:
+  static OrphanablePtr<ConnectionContext> Create();
+
+  // Sets the value of a registered property if it is not already set. Return
+  // false if the property is already set. If the property is not already
+  // set, an object of type Which is created using the passed args
+  // and stored in the map.
+  template <typename Which, typename... Args>
+  bool EmplaceIfUnset(Args&&... args) {
+    using Traits =
+        connection_context_detail::ConnectionContextPropertiesTraits<Which>;
+    Which* value = static_cast<Which*>(registered_properties()[Traits::id()]);
+    if (value == nullptr) {
+      registered_properties()[Traits::id()] = Traits::Construct(args...);
+      return true;
+    }
+    return false;
+  }
+
+  // Force updates the value of a registered property. It deletes any previously
+  // set value.
+  template <typename Which, typename... Args>
+  void Update(Args&&... args) {
+    using Traits =
+        connection_context_detail::ConnectionContextPropertiesTraits<Which>;
+    Which* prev = static_cast<Which*>(registered_properties()[Traits::id()]);
+    if (prev != nullptr) {
+      Traits::Destroy(Traits::id(), prev);
+    }
+    registered_properties()[Traits::id()] = Traits::Construct(args...);
+  }
+
+  // Returns the value of a registered property. If the property is not set,
+  // returns nullptr.
+  template <typename Which>
+  const Which* Get() {
+    return static_cast<Which*>(
+        registered_properties()
+            [connection_context_detail::ConnectionContextPropertiesTraits<
+                Which>::id()]);
+  }
+
+  void Orphan() override;
+
+  ~ConnectionContext() override;
+
+ private:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void** registered_properties() {
+    return reinterpret_cast<void**>(this + 1);
+  }
+
+  ConnectionContext();
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_SURFACE_CONNECTION_CONTEXT_H

data/src/core/lib/surface/filter_stack_call.h

@@ -131,7 +131,7 @@ class FilterStackCall final : public Call {
 
   static size_t InitialSizeEstimate() {
     return sizeof(FilterStackCall) +
-           sizeof(BatchControl) * kMaxConcurrentBatches;
+           (sizeof(BatchControl) * kMaxConcurrentBatches);
   }
 
   char* GetPeer() final;

data/src/core/lib/surface/init.cc

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/surface/init.h"
 
+#include <address_sorting/address_sorting.h>
 #include <grpc/fork.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
@@ -31,7 +32,7 @@
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "src/core/client_channel/backup_poller.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/experiments/config.h"
@@ -115,6 +116,7 @@ void grpc_init(void) {
     }
     grpc_iomgr_init();
     if (grpc_core::IsEventEngineDnsEnabled()) {
+      address_sorting_init();
       auto status = AresInit();
       if (!status.ok()) {
         VLOG(2) << "AresInit failed: " << status.message();
@@ -138,6 +140,7 @@ void grpc_shutdown_internal_locked(void)
     grpc_iomgr_shutdown_background_closure();
     grpc_timer_manager_set_threading(false);  // shutdown timer_manager thread
     if (grpc_core::IsEventEngineDnsEnabled()) {
+      address_sorting_shutdown();
       AresShutdown();
     } else {
       grpc_resolver_dns_ares_shutdown();

data/src/core/lib/surface/lame_client.cc

@@ -28,11 +28,11 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/pipe.h"

data/src/core/lib/surface/legacy_channel.cc

@@ -31,11 +31,11 @@
 #include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"

data/src/core/lib/surface/server_call.cc

@@ -50,6 +50,7 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/server/server_interface.h"
 #include "src/core/util/bitset.h"
+#include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
@@ -193,13 +194,18 @@ void ServerCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                      });
         });
     call_handler_.SpawnInfallible(
-        "final-batch", InfallibleBatch(std::move(primary_ops),
-                                       std::move(recv_trailing_metadata),
-                                       is_notify_tag_closure, notify_tag, cq_));
+        "final-batch",
+        GRPC_LATENT_SEE_PROMISE(
+            "ServerCallBatch",
+            InfallibleBatch(std::move(primary_ops),
+                            std::move(recv_trailing_metadata),
+                            is_notify_tag_closure, notify_tag, cq_)));
   } else {
     call_handler_.SpawnInfallible(
-        "batch", FallibleBatch(std::move(primary_ops), is_notify_tag_closure,
-                               notify_tag, cq_));
+        "batch", GRPC_LATENT_SEE_PROMISE(
+                     "ServerCallBatch",
+                     FallibleBatch(std::move(primary_ops),
+                                   is_notify_tag_closure, notify_tag, cq_)));
   }
 }
 

data/src/core/lib/surface/server_call.h

@@ -80,7 +80,6 @@ class ServerCall final : public Call, public DualRefCounted<ServerCall> {
         [self = WeakRefAsSubclass<ServerCall>(), error = std::move(error)] {
           self->call_handler_.PushServerTrailingMetadata(
               CancelledServerMetadataFromStatus(error));
-          return Empty{};
         });
   }
   bool is_trailers_only() const override {

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "44.1.1"; }
+const char* grpc_version_string(void) { return "44.2.0"; }
 
-const char* grpc_g_stands_for(void) { return "groovy"; }
+const char* grpc_g_stands_for(void) { return "gridiron"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -43,7 +43,7 @@ Timestamp BdpEstimator::CompletePing() {
   gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
   gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
   double dt = static_cast<double>(dt_ts.tv_sec) +
-              1e-9 * static_cast<double>(dt_ts.tv_nsec);
+              (1e-9 * static_cast<double>(dt_ts.tv_nsec));
   double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
   Duration start_inter_ping_delay = inter_ping_delay_;
   GRPC_TRACE_LOG(bdp_estimator, INFO)

data/src/core/lib/transport/call_filters.h

@@ -1585,8 +1585,8 @@ class CallFilters {
 
  private:
   template <typename Output, typename Input,
-            Input(CallFilters::*input_location),
-            filters_detail::Layout<Input>(filters_detail::StackData::*layout),
+            Input(CallFilters::* input_location),
+            filters_detail::Layout<Input>(filters_detail::StackData::* layout),
             void (CallState::*on_done)(), typename StackIterator>
   class MetadataExecutor {
    public:
@@ -1639,9 +1639,9 @@ class CallFilters {
     filters_detail::OperationExecutor<Input> executor_;
   };
 
-  template <MessageHandle(CallFilters::*input_location),
+  template <MessageHandle(CallFilters::* input_location),
             filters_detail::Layout<MessageHandle>(
-                filters_detail::StackData::*layout),
+                filters_detail::StackData::* layout),
             void (CallState::*on_done)(), typename StackIterator>
   class MessageExecutor {
    public:

data/src/core/lib/transport/call_final_info.h

@@ -41,7 +41,7 @@ void grpc_transport_move_stats(grpc_transport_stream_stats* from,
 
 struct grpc_call_stats {
   grpc_transport_stream_stats transport_stream_stats;
-  gpr_timespec latency;  // From call creating to enqueing of received status
+  gpr_timespec latency;  // From call creating to enqueuing of received status
 };
 /// Information about the call upon completion.
 struct grpc_call_final_info {

data/src/core/lib/transport/call_spine.cc

@@ -45,10 +45,8 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                 call_initiator.SpawnInfallible("finish-downstream-ok",
                                                [call_initiator]() mutable {
                                                  call_initiator.FinishSends();
-                                                 return Empty{};
                                                });
               }
-              return Empty{};
             });
       });
   call_handler.SpawnInfallible(
@@ -111,9 +109,7 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                   "recv_trailing",
                   [call_handler, md = std::move(md)]() mutable {
                     call_handler.PushServerTrailingMetadata(std::move(md));
-                    return Empty{};
                   });
-              return Empty{};
             });
       });
 }

data/src/core/lib/transport/interception_chain.h

@@ -106,7 +106,7 @@ class Interceptor : public UnstartedCallDestination {
     return Map(call_handler.PullClientInitialMetadata(),
                [call_handler, destination = wrapped_destination_](
                    ValueOrFailure<ClientMetadataHandle> metadata) mutable
-               -> ValueOrFailure<HijackedCall> {
+                   -> ValueOrFailure<HijackedCall> {
                  if (!metadata.ok()) return Failure{};
                  return HijackedCall(std::move(metadata.value()),
                                      std::move(destination),

data/src/core/lib/transport/metadata_batch.cc

@@ -41,11 +41,20 @@ void DebugStringBuilder::AddAfterRedaction(absl::string_view key,
   if (IsAllowListed(key)) {
     Add(key, value);
   } else {
-    Add(key, absl::StrCat(value.size(), " bytes redacted by allow listing."));
+    // If the type of metadata is not in the allow list, we want to prevent it
+    // from getting logged. Custom metadata types may have sensitive information
+    // that should never be logged. Programatically, we have no way to know
+    // which data is sensitive and which is not. So we redact all values which
+    // are not in the allow list.
+    Add(key,
+        absl::StrCat(value.size(), " bytes redacted for security reasons."));
   }
 }
 
 bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
+  // We have intentionally not allowed for any way to add to the allow list at
+  // run time, (using a flag or some other setting) because such workarounds
+  // may lead to security issues.
   static const absl::NoDestructor<absl::flat_hash_set<std::string>> allow_list(
       [] {
         absl::flat_hash_set<std::string> allow_list;
@@ -74,8 +83,8 @@ bool DebugStringBuilder::IsAllowListed(const absl::string_view key) const {
         allow_list.insert(std::string(LbTokenMetadata::key()));
         allow_list.insert(std::string(TeMetadata::key()));
         allow_list.insert(std::string(UserAgentMetadata::key()));
+        allow_list.insert(std::string(W3CTraceParentMetadata::key()));
         allow_list.insert(std::string(XEnvoyPeerMetadata::key()));
-
         // go/keep-sorted end
         // go/keep-sorted start
         allow_list.insert(std::string(GrpcCallWasCancelled::DebugKey()));

data/src/core/lib/transport/metadata_batch.h

@@ -468,6 +468,14 @@ struct LbCostBinMetadata {
                                   MetadataParseErrorFn on_error);
 };
 
+// traceparent metadata
+struct W3CTraceParentMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static constexpr bool kTransferOnTrailersOnly = false;
+  using CompressionTraits = NoCompressionCompressor;
+  static absl::string_view key() { return "traceparent"; }
+};
+
 // Annotation added by a transport to note whether a failed request was never
 // placed on the wire, or never seen by a server.
 struct GrpcStreamNetworkState {
@@ -1582,7 +1590,7 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
     grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
-    grpc_core::XEnvoyPeerMetadata,
+    grpc_core::XEnvoyPeerMetadata, grpc_core::W3CTraceParentMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
     grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,

data/src/core/lib/transport/metadata_compression_traits.h

@@ -42,7 +42,7 @@ struct StableValueCompressor {};
 template <typename T, T value>
 struct KnownValueCompressor {};
 
-// Values are uncompressible, but expect the key to be in most requests and try
+// Values are incompressable, but expect the key to be in most requests and try
 // and compress that.
 struct FrequentKeyWithNoValueCompressionCompressor {};
 
@@ -56,7 +56,7 @@ struct SmallIntegralValuesCompressor {};
 // Specialty compressor for grpc-timeout metadata.
 struct TimeoutCompressor {};
 
-// Specialty compressors for HTTP/2 psuedo headers.
+// Specialty compressors for HTTP/2 pseudo headers.
 struct HttpSchemeCompressor {};
 struct HttpMethodCompressor {};
 struct HttpStatusCompressor {};

data/src/core/lib/transport/timeout_encoding.cc

@@ -258,12 +258,12 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
   Duration timeout;
   switch (*p) {
     case 'n':
-      timeout =
-          Duration::Milliseconds(x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0));
+      timeout = Duration::Milliseconds((x / GPR_NS_PER_MS) +
+                                       (x % GPR_NS_PER_MS != 0));
       break;
     case 'u':
-      timeout =
-          Duration::Milliseconds(x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0));
+      timeout = Duration::Milliseconds((x / GPR_US_PER_MS) +
+                                       (x % GPR_US_PER_MS != 0));
       break;
     case 'm':
       timeout = Duration::Milliseconds(x);

data/src/core/lib/transport/transport_framing_endpoint_extension.h

@@ -0,0 +1,47 @@
+// Copyright 2024 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_TRANSPORT_FRAMING_ENDPOINT_EXTENSION_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_TRANSPORT_FRAMING_ENDPOINT_EXTENSION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/strings/string_view.h"
+#include "src/core/lib/slice/slice_buffer.h"
+
+namespace grpc_core {
+
+/// An Endpoint extension class that will be supported by EventEngine endpoints
+/// which can send data to a transport and receive data from it.
+class TransportFramingEndpointExtension {
+ public:
+  virtual ~TransportFramingEndpointExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.transport.extension.transport_framing_endpoint_"
+           "extension";
+  }
+
+  // Send data to transport through `cb`. The data will be sent in a single
+  // frame.
+  virtual void SetSendFrameCallback(
+      absl::AnyInvocable<void(SliceBuffer* data)> cb) = 0;
+
+  /// Receive data from transport. The data will be from a single frame.
+  virtual void ReceiveFrame(SliceBuffer data) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_TRANSPORT_FRAMING_ENDPOINT_EXTENSION_H

data/src/core/load_balancing/child_policy_handler.cc

@@ -27,8 +27,8 @@
 #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/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"

data/src/core/load_balancing/endpoint_list.cc

@@ -30,8 +30,8 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/load_balancing/delegating_helper.h"
 #include "src/core/load_balancing/lb_policy.h"

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -93,9 +93,9 @@
 #include "absl/types/variant.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/closure.h"

data/src/core/load_balancing/lb_policy.h

@@ -84,7 +84,7 @@ namespace grpc_core {
 ///   - A SubchannelPicker, which handles the data plane work of
 ///     determining which subchannel a given call should be sent on.
 
-/// LoadBalacingPolicy API.
+/// LoadBalancingPolicy API.
 ///
 /// Note: All methods with a "Locked" suffix must be called from the
 /// work_serializer passed to the constructor.

data/src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -43,9 +43,9 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -924,7 +924,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     double stdev = std::sqrt(variance);
     const double success_rate_stdev_factor =
         static_cast<double>(config.success_rate_ejection->stdev_factor) / 1000;
-    double ejection_threshold = mean - stdev * success_rate_stdev_factor;
+    double ejection_threshold = mean - (stdev * success_rate_stdev_factor);
     GRPC_TRACE_LOG(outlier_detection_lb, INFO)
         << "[outlier_detection_lb " << parent_.get() << "] stdev=" << stdev
         << ", ejection_threshold=" << ejection_threshold;

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -39,9 +39,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -423,7 +423,7 @@ PickFirst::PickFirst(Args args)
 
 PickFirst::~PickFirst() {
   GRPC_TRACE_LOG(pick_first, INFO) << "Destroying Pick First " << this;
-  CHECK(subchannel_list_ == nullptr);
+  CHECK_EQ(subchannel_list_.get(), nullptr);
 }
 
 void PickFirst::ShutdownLocked() {
@@ -744,6 +744,8 @@ void PickFirst::SubchannelList::SubchannelData::SubchannelState::
   // If we're still part of a subchannel list trying to connect, check
   // if we're connected.
   if (subchannel_data_ != nullptr) {
+    CHECK_EQ(pick_first_->subchannel_list_.get(),
+             subchannel_data_->subchannel_list_);
     // If the subchannel is READY, use it.
     // Otherwise, tell the subchannel list to keep trying.
     if (new_state == GRPC_CHANNEL_READY) {
@@ -754,7 +756,7 @@ void PickFirst::SubchannelList::SubchannelData::SubchannelState::
     return;
   }
   // We aren't trying to connect, so we must be the selected subchannel.
-  CHECK(pick_first_->selected_.get() == this);
+  CHECK_EQ(pick_first_->selected_.get(), this);
   GRPC_TRACE_LOG(pick_first, INFO)
       << "Pick First " << pick_first_.get()
       << " selected subchannel connectivity changed to "
@@ -803,15 +805,14 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
       << ", p->subchannel_list_=" << p->subchannel_list_.get()
       << ", p->subchannel_list_->shutting_down_="
       << p->subchannel_list_->shutting_down_;
-
   if (subchannel_list_->shutting_down_) return;
   // The notification must be for a subchannel in the current list.
-  CHECK(subchannel_list_ == p->subchannel_list_.get());
+  CHECK_EQ(subchannel_list_, p->subchannel_list_.get());
   // SHUTDOWN should never happen.
-  CHECK(new_state != GRPC_CHANNEL_SHUTDOWN);
+  CHECK_NE(new_state, GRPC_CHANNEL_SHUTDOWN);
   // READY should be caught by SubchannelState, in which case it will
   // not call us in the first place.
-  CHECK(new_state != GRPC_CHANNEL_READY);
+  CHECK_NE(new_state, GRPC_CHANNEL_READY);
   // Update state.
   absl::optional<grpc_connectivity_state> old_state = connectivity_state_;
   connectivity_state_ = new_state;
@@ -935,7 +936,7 @@ void PickFirst::SubchannelList::SubchannelData::RequestConnectionWithTimer() {
   if (connectivity_state_ == GRPC_CHANNEL_IDLE) {
     subchannel_state_->RequestConnection();
   } else {
-    CHECK(connectivity_state_ == GRPC_CHANNEL_CONNECTING);
+    CHECK_EQ(connectivity_state_.value(), GRPC_CHANNEL_CONNECTING);
   }
   // If this is not the last subchannel in the list, start the timer.
   if (index_ != subchannel_list_->size() - 1) {
@@ -1021,6 +1022,8 @@ void PickFirst::SubchannelList::Orphan() {
       << "[PF " << policy_.get() << "] Shutting down subchannel_list " << this;
   CHECK(!shutting_down_);
   shutting_down_ = true;
+  // Shut down subchannels.
+  subchannels_.clear();
   // Cancel Happy Eyeballs timer, if any.
   if (timer_handle_.has_value()) {
     policy_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);

data/src/core/load_balancing/priority/priority.cc

@@ -37,8 +37,8 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"