grpc 1.56.2 → 1.57.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -24,6 +24,7 @@
 
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "upb/mem/arena.h"
 
 #include <grpc/slice.h>
@@ -56,7 +57,8 @@ struct GrpcLbResponse {
 };
 
 // Creates a serialized grpclb request.
-grpc_slice GrpcLbRequestCreate(const char* lb_service_name, upb_Arena* arena);
+grpc_slice GrpcLbRequestCreate(absl::string_view lb_service_name,
+                               upb_Arena* arena);
 
 // Creates a serialized grpclb load report request.
 grpc_slice GrpcLbLoadReportRequestCreate(

data/src/core/ext/filters/client_channel/lb_policy/health_check_client.cc

@@ -29,18 +29,22 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "upb/base/string_view.h"
 #include "upb/upb.hpp"
 
+#include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/ext/filters/client_channel/lb_policy/health_check_client_internal.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -351,28 +355,40 @@ void HealthProducer::Orphan() {
   subchannel_->RemoveDataProducer(this);
 }
 
-void HealthProducer::AddWatcher(HealthWatcher* watcher,
-                                const std::string& health_check_service_name) {
+void HealthProducer::AddWatcher(
+    HealthWatcher* watcher,
+    const absl::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_add_pollset_set(interested_parties_,
                                    watcher->interested_parties());
-  auto it = health_checkers_.emplace(health_check_service_name, nullptr).first;
-  auto& health_checker = it->second;
-  if (health_checker == nullptr) {
-    health_checker = MakeOrphanable<HealthChecker>(WeakRef(), it->first);
+  if (!health_check_service_name.has_value()) {
+    watcher->Notify(state_, status_);
+    non_health_watchers_.insert(watcher);
+  } else {
+    auto it =
+        health_checkers_.emplace(*health_check_service_name, nullptr).first;
+    auto& health_checker = it->second;
+    if (health_checker == nullptr) {
+      health_checker = MakeOrphanable<HealthChecker>(WeakRef(), it->first);
+    }
+    health_checker->AddWatcherLocked(watcher);
   }
-  health_checker->AddWatcherLocked(watcher);
 }
 
 void HealthProducer::RemoveWatcher(
-    HealthWatcher* watcher, const std::string& health_check_service_name) {
+    HealthWatcher* watcher,
+    const absl::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_del_pollset_set(interested_parties_,
                                    watcher->interested_parties());
-  auto it = health_checkers_.find(health_check_service_name);
-  if (it == health_checkers_.end()) return;
-  const bool empty = it->second->RemoveWatcherLocked(watcher);
-  if (empty) health_checkers_.erase(it);
+  if (!health_check_service_name.has_value()) {
+    non_health_watchers_.erase(watcher);
+  } else {
+    auto it = health_checkers_.find(*health_check_service_name);
+    if (it == health_checkers_.end()) return;
+    const bool empty = it->second->RemoveWatcherLocked(watcher);
+    if (empty) health_checkers_.erase(it);
+  }
 }
 
 void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
@@ -393,6 +409,9 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
   for (const auto& p : health_checkers_) {
     p.second->OnConnectivityStateChangeLocked(state, status);
   }
+  for (HealthWatcher* watcher : non_health_watchers_) {
+    watcher->Notify(state, status);
+  }
 }
 
 //
@@ -443,12 +462,16 @@ void HealthWatcher::Notify(grpc_connectivity_state state, absl::Status status) {
 
 std::unique_ptr<SubchannelInterface::DataWatcherInterface>
 MakeHealthCheckWatcher(
-    std::shared_ptr<WorkSerializer> work_serializer,
-    absl::string_view health_check_service_name,
+    std::shared_ptr<WorkSerializer> work_serializer, const ChannelArgs& args,
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher) {
+  absl::optional<std::string> health_check_service_name;
+  if (!args.GetBool(GRPC_ARG_INHIBIT_HEALTH_CHECKING).value_or(false)) {
+    health_check_service_name =
+        args.GetOwnedString(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME);
+  }
   return std::make_unique<HealthWatcher>(std::move(work_serializer),
-                                         health_check_service_name,
+                                         std::move(health_check_service_name),
                                          std::move(watcher));
 }
 

data/src/core/ext/filters/client_channel/lb_policy/health_check_client.h

@@ -21,8 +21,7 @@
 
 #include <memory>
 
-#include "absl/strings/string_view.h"
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
 
@@ -39,13 +38,12 @@ namespace grpc_core {
 // like this:
 //   subchannel->AddDataWatcher(
 //       MakeHealthCheckWatcher(
-//           work_serializer(), health_check_service_name,
+//           work_serializer(), channel_args,
 //           std::make_unique<MyConnectivityStateWatcherSubclass>(...)));
 
 std::unique_ptr<SubchannelInterface::DataWatcherInterface>
 MakeHealthCheckWatcher(
-    std::shared_ptr<WorkSerializer> work_serializer,
-    absl::string_view health_check_service_name,
+    std::shared_ptr<WorkSerializer> work_serializer, const ChannelArgs& args,
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher);
 

data/src/core/ext/filters/client_channel/lb_policy/health_check_client_internal.h

@@ -28,6 +28,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
 #include <grpc/impl/connectivity_state.h>
 
@@ -68,9 +69,10 @@ class HealthProducer : public Subchannel::DataProducerInterface {
   UniqueTypeName type() const override { return Type(); }
 
   void AddWatcher(HealthWatcher* watcher,
-                  const std::string& health_check_service_name);
-  void RemoveWatcher(HealthWatcher* watcher,
-                     const std::string& health_check_service_name);
+                  const absl::optional<std::string>& health_check_service_name);
+  void RemoveWatcher(
+      HealthWatcher* watcher,
+      const absl::optional<std::string>& health_check_service_name);
 
  private:
   class ConnectivityWatcher;
@@ -148,6 +150,7 @@ class HealthProducer : public Subchannel::DataProducerInterface {
   std::map<std::string /*health_check_service_name*/,
            OrphanablePtr<HealthChecker>>
       health_checkers_ ABSL_GUARDED_BY(&mu_);
+  std::set<HealthWatcher*> non_health_watchers_ ABSL_GUARDED_BY(&mu_);
 };
 
 // A data watcher that handles health checking.
@@ -155,18 +158,31 @@ class HealthWatcher : public InternalSubchannelDataWatcherInterface {
  public:
   HealthWatcher(
       std::shared_ptr<WorkSerializer> work_serializer,
-      absl::string_view health_check_service_name,
+      absl::optional<std::string> health_check_service_name,
       std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher)
       : work_serializer_(std::move(work_serializer)),
-        health_check_service_name_(health_check_service_name),
+        health_check_service_name_(std::move(health_check_service_name)),
         watcher_(std::move(watcher)) {}
   ~HealthWatcher() override;
 
+  UniqueTypeName type() const override { return HealthProducer::Type(); }
+
   // When the client channel sees this wrapper, it will pass it the real
   // subchannel to use.
   void SetSubchannel(Subchannel* subchannel) override;
 
+  // For intercepting the watcher before it gets up to the real subchannel.
+  std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
+  TakeWatcher() {
+    return std::move(watcher_);
+  }
+  void SetWatcher(
+      std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
+          watcher) {
+    watcher_ = std::move(watcher);
+  }
+
   void Notify(grpc_connectivity_state state, absl::Status status);
 
   grpc_pollset_set* interested_parties() const {
@@ -175,7 +191,7 @@ class HealthWatcher : public InternalSubchannelDataWatcherInterface {
 
  private:
   std::shared_ptr<WorkSerializer> work_serializer_;
-  std::string health_check_service_name_;
+  absl::optional<std::string> health_check_service_name_;
   std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
       watcher_;
   RefCountedPtr<HealthProducer> producer_;

data/src/core/ext/filters/client_channel/lb_policy/oob_backend_metric_internal.h

@@ -102,6 +102,8 @@ class OrcaWatcher : public InternalSubchannelDataWatcherInterface {
   Duration report_interval() const { return report_interval_; }
   OobBackendMetricWatcher* watcher() const { return watcher_.get(); }
 
+  UniqueTypeName type() const override { return OrcaProducer::Type(); }
+
   // When the client channel sees this wrapper, it will pass it the real
   // subchannel to use.
   void SetSubchannel(Subchannel* subchannel) override;

data/src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.cc

@@ -43,20 +43,25 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
+#include "src/core/ext/filters/client_channel/lb_policy/health_check_client_internal.h"
+#include "src/core/ext/filters/client_channel/subchannel_interface_internal.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/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -68,9 +73,6 @@ namespace grpc_core {
 
 TraceFlag grpc_outlier_detection_lb_trace(false, "outlier_detection_lb");
 
-const char* DisableOutlierDetectionAttribute::kName =
-    "disable_outlier_detection";
-
 namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
@@ -123,9 +125,12 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
   class SubchannelWrapper : public DelegatingSubchannel {
    public:
     SubchannelWrapper(RefCountedPtr<SubchannelState> subchannel_state,
-                      RefCountedPtr<SubchannelInterface> subchannel)
+                      RefCountedPtr<SubchannelInterface> subchannel,
+                      bool disable_via_raw_connectivity_watch)
         : DelegatingSubchannel(std::move(subchannel)),
-          subchannel_state_(std::move(subchannel_state)) {
+          subchannel_state_(std::move(subchannel_state)),
+          disable_via_raw_connectivity_watch_(
+              disable_via_raw_connectivity_watch) {
       if (subchannel_state_ != nullptr) {
         subchannel_state_->AddSubchannel(this);
         if (subchannel_state_->ejection_time().has_value()) {
@@ -150,14 +155,27 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     void CancelConnectivityStateWatch(
         ConnectivityStateWatcherInterface* watcher) override;
 
+    void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override;
+
     RefCountedPtr<SubchannelState> subchannel_state() const {
       return subchannel_state_;
     }
 
    private:
+    // TODO(roth): As a temporary hack, this needs to handle watchers
+    // stored as both unique_ptr<> and shared_ptr<>, since the former is
+    // used for raw connectivity state watches and the latter is used
+    // for health watches.  This hack will go away as part of implementing
+    // dualstack backend support.
     class WatcherWrapper
         : public SubchannelInterface::ConnectivityStateWatcherInterface {
      public:
+      WatcherWrapper(std::shared_ptr<
+                         SubchannelInterface::ConnectivityStateWatcherInterface>
+                         health_watcher,
+                     bool ejected)
+          : watcher_(std::move(health_watcher)), ejected_(ejected) {}
+
       WatcherWrapper(std::unique_ptr<
                          SubchannelInterface::ConnectivityStateWatcherInterface>
                          watcher,
@@ -167,7 +185,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
       void Eject() {
         ejected_ = true;
         if (last_seen_state_.has_value()) {
-          watcher_->OnConnectivityStateChange(
+          watcher()->OnConnectivityStateChange(
               GRPC_CHANNEL_TRANSIENT_FAILURE,
               absl::UnavailableError(
                   "subchannel ejected by outlier detection"));
@@ -177,8 +195,8 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
       void Uneject() {
         ejected_ = false;
         if (last_seen_state_.has_value()) {
-          watcher_->OnConnectivityStateChange(*last_seen_state_,
-                                              last_seen_status_);
+          watcher()->OnConnectivityStateChange(*last_seen_state_,
+                                               last_seen_status_);
         }
       }
 
@@ -193,16 +211,30 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
             status = absl::UnavailableError(
                 "subchannel ejected by outlier detection");
           }
-          watcher_->OnConnectivityStateChange(new_state, status);
+          watcher()->OnConnectivityStateChange(new_state, status);
         }
       }
 
       grpc_pollset_set* interested_parties() override {
-        return watcher_->interested_parties();
+        return watcher()->interested_parties();
       }
 
      private:
-      std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
+      SubchannelInterface::ConnectivityStateWatcherInterface* watcher() const {
+        return Match(
+            watcher_,
+            [](const std::shared_ptr<
+                SubchannelInterface::ConnectivityStateWatcherInterface>&
+                   watcher) { return watcher.get(); },
+            [](const std::unique_ptr<
+                SubchannelInterface::ConnectivityStateWatcherInterface>&
+                   watcher) { return watcher.get(); });
+      }
+
+      absl::variant<std::shared_ptr<
+                        SubchannelInterface::ConnectivityStateWatcherInterface>,
+                    std::unique_ptr<
+                        SubchannelInterface::ConnectivityStateWatcherInterface>>
           watcher_;
       absl::optional<grpc_connectivity_state> last_seen_state_;
       absl::Status last_seen_status_;
@@ -210,10 +242,12 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     };
 
     RefCountedPtr<SubchannelState> subchannel_state_;
+    const bool disable_via_raw_connectivity_watch_;
     bool ejected_ = false;
     std::map<SubchannelInterface::ConnectivityStateWatcherInterface*,
              WatcherWrapper*>
         watchers_;
+    WatcherWrapper* watcher_wrapper_ = nullptr;  // For health watching.
   };
 
   class SubchannelState : public RefCounted<SubchannelState> {
@@ -328,27 +362,17 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     bool counting_enabled_;
   };
 
-  class Helper : public ChannelControlHelper {
+  class Helper
+      : public ParentOwningDelegatingChannelControlHelper<OutlierDetectionLb> {
    public:
     explicit Helper(RefCountedPtr<OutlierDetectionLb> outlier_detection_policy)
-        : outlier_detection_policy_(std::move(outlier_detection_policy)) {}
-
-    ~Helper() override {
-      outlier_detection_policy_.reset(DEBUG_LOCATION, "Helper");
-    }
+        : ParentOwningDelegatingChannelControlHelper(
+              std::move(outlier_detection_policy)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         ServerAddress address, const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
-    void RequestReresolution() override;
-    absl::string_view GetAuthority() override;
-    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
-    void AddTraceEvent(TraceSeverity severity,
-                       absl::string_view message) override;
-
-   private:
-    RefCountedPtr<OutlierDetectionLb> outlier_detection_policy_;
   };
 
   class EjectionTimer : public InternallyRefCounted<EjectionTimer> {
@@ -412,6 +436,7 @@ void OutlierDetectionLb::SubchannelWrapper::Eject() {
     ++it;
     watcher->Eject();
   }
+  if (watcher_wrapper_ != nullptr) watcher_wrapper_->Eject();
 }
 
 void OutlierDetectionLb::SubchannelWrapper::Uneject() {
@@ -419,10 +444,15 @@ void OutlierDetectionLb::SubchannelWrapper::Uneject() {
   for (auto& watcher : watchers_) {
     watcher.second->Uneject();
   }
+  if (watcher_wrapper_ != nullptr) watcher_wrapper_->Uneject();
 }
 
 void OutlierDetectionLb::SubchannelWrapper::WatchConnectivityState(
     std::unique_ptr<ConnectivityStateWatcherInterface> watcher) {
+  if (disable_via_raw_connectivity_watch_) {
+    wrapped_subchannel()->WatchConnectivityState(std::move(watcher));
+    return;
+  }
   ConnectivityStateWatcherInterface* watcher_ptr = watcher.get();
   auto watcher_wrapper =
       std::make_unique<WatcherWrapper>(std::move(watcher), ejected_);
@@ -432,12 +462,29 @@ void OutlierDetectionLb::SubchannelWrapper::WatchConnectivityState(
 
 void OutlierDetectionLb::SubchannelWrapper::CancelConnectivityStateWatch(
     ConnectivityStateWatcherInterface* watcher) {
+  if (disable_via_raw_connectivity_watch_) {
+    wrapped_subchannel()->CancelConnectivityStateWatch(watcher);
+    return;
+  }
   auto it = watchers_.find(watcher);
   if (it == watchers_.end()) return;
   wrapped_subchannel()->CancelConnectivityStateWatch(it->second);
   watchers_.erase(it);
 }
 
+void OutlierDetectionLb::SubchannelWrapper::AddDataWatcher(
+    std::unique_ptr<DataWatcherInterface> watcher) {
+  auto* w = static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get());
+  if (w->type() == HealthProducer::Type()) {
+    auto* health_watcher = static_cast<HealthWatcher*>(watcher.get());
+    auto watcher_wrapper = std::make_shared<WatcherWrapper>(
+        health_watcher->TakeWatcher(), ejected_);
+    watcher_wrapper_ = watcher_wrapper.get();
+    health_watcher->SetWatcher(std::move(watcher_wrapper));
+  }
+  DelegatingSubchannel::AddDataWatcher(std::move(watcher));
+}
+
 //
 // OutlierDetectionLb::Picker::SubchannelCallTracker
 //
@@ -551,16 +598,6 @@ OutlierDetectionLb::~OutlierDetectionLb() {
 
 std::string OutlierDetectionLb::MakeKeyForAddress(
     const ServerAddress& address) {
-  // If the address has the DisableOutlierDetectionAttribute attribute,
-  // ignore it.
-  // TODO(roth): This is a hack to prevent outlier_detection from
-  // working with pick_first, as per discussion in
-  // https://github.com/grpc/grpc/issues/32967.  Remove this as part of
-  // implementing dualstack backend support.
-  if (address.GetAttribute(DisableOutlierDetectionAttribute::kName) !=
-      nullptr) {
-    return "";
-  }
   // Use only the address, not the attributes.
   auto addr_str = grpc_sockaddr_to_string(&address.address(), false);
   // If address couldn't be stringified, ignore it.
@@ -739,25 +776,35 @@ OrphanablePtr<LoadBalancingPolicy> OutlierDetectionLb::CreateChildPolicyLocked(
 
 RefCountedPtr<SubchannelInterface> OutlierDetectionLb::Helper::CreateSubchannel(
     ServerAddress address, const ChannelArgs& args) {
-  if (outlier_detection_policy_->shutting_down_) return nullptr;
+  if (parent()->shutting_down_) return nullptr;
+  // If the address has the DisableOutlierDetectionAttribute attribute,
+  // ignore it for raw connectivity state updates.
+  // TODO(roth): This is a hack to prevent outlier_detection from
+  // working with pick_first, as per discussion in
+  // https://github.com/grpc/grpc/issues/32967.  Remove this as part of
+  // implementing dualstack backend support.
+  const bool disable_via_raw_connectivity_watch =
+      address.args().GetInt(GRPC_ARG_OUTLIER_DETECTION_DISABLE) == 1;
   RefCountedPtr<SubchannelState> subchannel_state;
   std::string key = MakeKeyForAddress(address);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
     gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] using key %s for subchannel address %s",
-            outlier_detection_policy_.get(), key.c_str(),
-            address.ToString().c_str());
+            "[outlier_detection_lb %p] using key %s for subchannel "
+            "address %s, disable_via_raw_connectivity_watch=%d",
+            parent(), key.c_str(), address.ToString().c_str(),
+            disable_via_raw_connectivity_watch);
   }
   if (!key.empty()) {
-    auto it = outlier_detection_policy_->subchannel_state_map_.find(key);
-    if (it != outlier_detection_policy_->subchannel_state_map_.end()) {
+    auto it = parent()->subchannel_state_map_.find(key);
+    if (it != parent()->subchannel_state_map_.end()) {
       subchannel_state = it->second->Ref();
     }
   }
   auto subchannel = MakeRefCounted<SubchannelWrapper>(
       subchannel_state,
-      outlier_detection_policy_->channel_control_helper()->CreateSubchannel(
-          std::move(address), args));
+      parent()->channel_control_helper()->CreateSubchannel(std::move(address),
+                                                           args),
+      disable_via_raw_connectivity_watch);
   if (subchannel_state != nullptr) {
     subchannel_state->AddSubchannel(subchannel.get());
   }
@@ -767,41 +814,20 @@ RefCountedPtr<SubchannelInterface> OutlierDetectionLb::Helper::CreateSubchannel(
 void OutlierDetectionLb::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
-  if (outlier_detection_policy_->shutting_down_) return;
+  if (parent()->shutting_down_) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
     gpr_log(GPR_INFO,
             "[outlier_detection_lb %p] child connectivity state update: "
             "state=%s (%s) picker=%p",
-            outlier_detection_policy_.get(), ConnectivityStateName(state),
-            status.ToString().c_str(), picker.get());
+            parent(), ConnectivityStateName(state), status.ToString().c_str(),
+            picker.get());
   }
   // Save the state and picker.
-  outlier_detection_policy_->state_ = state;
-  outlier_detection_policy_->status_ = status;
-  outlier_detection_policy_->picker_ = std::move(picker);
+  parent()->state_ = state;
+  parent()->status_ = status;
+  parent()->picker_ = std::move(picker);
   // Wrap the picker and return it to the channel.
-  outlier_detection_policy_->MaybeUpdatePickerLocked();
-}
-
-void OutlierDetectionLb::Helper::RequestReresolution() {
-  if (outlier_detection_policy_->shutting_down_) return;
-  outlier_detection_policy_->channel_control_helper()->RequestReresolution();
-}
-
-absl::string_view OutlierDetectionLb::Helper::GetAuthority() {
-  return outlier_detection_policy_->channel_control_helper()->GetAuthority();
-}
-
-grpc_event_engine::experimental::EventEngine*
-OutlierDetectionLb::Helper::GetEventEngine() {
-  return outlier_detection_policy_->channel_control_helper()->GetEventEngine();
-}
-
-void OutlierDetectionLb::Helper::AddTraceEvent(TraceSeverity severity,
-                                               absl::string_view message) {
-  if (outlier_detection_policy_->shutting_down_) return;
-  outlier_detection_policy_->channel_control_helper()->AddTraceEvent(severity,
-                                                                     message);
+  parent()->MaybeUpdatePickerLocked();
 }
 
 //

data/src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h

@@ -21,9 +21,6 @@
 
 #include <stdint.h>  // for uint32_t
 
-#include <memory>
-#include <string>
-
 #include "absl/types/optional.h"
 
 #include "src/core/lib/gprpp/time.h"
@@ -96,19 +93,8 @@ struct OutlierDetectionConfig {
 // TODO(roth): This is a horrible hack used to disable outlier detection
 // when used with the pick_first policy.  Remove this as part of
 // implementing the dualstack backend design.
-class DisableOutlierDetectionAttribute
-    : public ServerAddress::AttributeInterface {
- public:
-  static const char* kName;
-
-  std::unique_ptr<AttributeInterface> Copy() const override {
-    return std::make_unique<DisableOutlierDetectionAttribute>();
-  }
-
-  int Cmp(const AttributeInterface*) const override { return true; }
-
-  std::string ToString() const override { return "true"; }
-};
+#define GRPC_ARG_OUTLIER_DETECTION_DISABLE \
+  GRPC_ARG_NO_SUBCHANNEL_PREFIX "outlier_detection_disable"
 
 }  // namespace grpc_core