grpc 1.60.0 → 1.61.0.pre2

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_override_host.h

@@ -21,7 +21,6 @@
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/xds/xds_health_status.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
@@ -46,21 +45,18 @@ class XdsOverrideHostLbConfig : public LoadBalancingPolicy::Config {
 
   absl::string_view name() const override { return Name(); }
 
+  const std::string& cluster_name() const { return cluster_name_; }
   RefCountedPtr<LoadBalancingPolicy::Config> child_config() const {
     return child_config_;
   }
 
-  XdsHealthStatusSet override_host_status_set() const {
-    return override_host_status_set_;
-  }
-
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
   void JsonPostLoad(const Json& json, const JsonArgs&,
                     ValidationErrors* errors);
 
  private:
+  std::string cluster_name_;
   RefCountedPtr<LoadBalancingPolicy::Config> child_config_;
-  XdsHealthStatusSet override_host_status_set_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_wrr_locality.cc

@@ -21,7 +21,6 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -166,14 +165,14 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
     gpr_log(GPR_INFO, "[xds_wrr_locality_lb %p] Received update", this);
   }
-  RefCountedPtr<XdsWrrLocalityLbConfig> config = std::move(args.config);
+  auto config = args.config.TakeAsSubclass<XdsWrrLocalityLbConfig>();
   // Scan the addresses to find the weight for each locality.
   std::map<std::string, uint32_t> locality_weights;
   if (args.addresses.ok()) {
-    for (const auto& address : *args.addresses) {
-      auto* locality_name = address.args().GetObject<XdsLocalityName>();
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+      auto* locality_name = endpoint.args().GetObject<XdsLocalityName>();
       uint32_t weight =
-          address.args().GetInt(GRPC_ARG_XDS_LOCALITY_WEIGHT).value_or(0);
+          endpoint.args().GetInt(GRPC_ARG_XDS_LOCALITY_WEIGHT).value_or(0);
       if (locality_name != nullptr && weight > 0) {
         auto p = locality_weights.emplace(
             locality_name->AsHumanReadableString(), weight);
@@ -184,7 +183,7 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
                   p.first->first.c_str(), p.first->second, weight);
         }
       }
-    }
+    });
   }
   // Construct the config for the weighted_target policy.
   Json::Object weighted_targets;
@@ -253,8 +252,8 @@ OrphanablePtr<LoadBalancingPolicy> XdsWrrLocalityLb::CreateChildPolicyLocked(
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
-  lb_policy_args.channel_control_helper =
-      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+  lb_policy_args.channel_control_helper = std::make_unique<Helper>(
+      RefAsSubclass<XdsWrrLocalityLb>(DEBUG_LOCATION, "Helper"));
   auto lb_policy =
       CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "weighted_target_experimental", std::move(lb_policy_args));

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -224,7 +224,8 @@ AresClientChannelDNSResolver::~AresClientChannelDNSResolver() {
 
 OrphanablePtr<Orphanable> AresClientChannelDNSResolver::StartRequest() {
   return MakeOrphanable<AresRequestWrapper>(
-      Ref(DEBUG_LOCATION, "dns-resolving"));
+      RefAsSubclass<AresClientChannelDNSResolver>(DEBUG_LOCATION,
+                                                  "dns-resolving"));
 }
 
 void AresClientChannelDNSResolver::AresRequestWrapper::OnHostnameResolved(

data/src/core/ext/filters/client_channel/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -210,7 +210,9 @@ OrphanablePtr<Orphanable> EventEngineClientChannelDNSResolver::StartRequest() {
     return nullptr;
   }
   return MakeOrphanable<EventEngineDNSRequestWrapper>(
-      Ref(DEBUG_LOCATION, "dns-resolving"), std::move(*dns_resolver));
+      RefAsSubclass<EventEngineClientChannelDNSResolver>(DEBUG_LOCATION,
+                                                         "dns-resolving"),
+      std::move(*dns_resolver));
 }
 
 // ----------------------------------------------------------------------------

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -85,7 +85,7 @@ FakeResolver::FakeResolver(ResolverArgs args)
       response_generator_(
           args.args.GetObjectRef<FakeResolverResponseGenerator>()) {
   if (response_generator_ != nullptr) {
-    response_generator_->SetFakeResolver(Ref());
+    response_generator_->SetFakeResolver(RefAsSubclass<FakeResolver>());
   }
 }
 
@@ -137,7 +137,7 @@ void FakeResolverResponseGenerator::SetResponseAndNotify(
       if (notify_when_set != nullptr) notify_when_set->Notify();
       return;
     }
-    resolver = resolver_->Ref();
+    resolver = resolver_;
   }
   SendResultToResolver(std::move(resolver), std::move(result), notify_when_set);
 }

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -154,7 +154,7 @@ void GoogleCloud2ProdResolver::StartLocked() {
   zone_query_ = MakeOrphanable<MetadataQuery>(
       metadata_server_name_, std::string(MetadataQuery::kZoneAttribute),
       &pollent_,
-      [resolver = static_cast<RefCountedPtr<GoogleCloud2ProdResolver>>(Ref())](
+      [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
           std::string /* attribute */,
           absl::StatusOr<std::string> result) mutable {
         resolver->work_serializer_->Run(
@@ -168,7 +168,7 @@ void GoogleCloud2ProdResolver::StartLocked() {
   ipv6_query_ = MakeOrphanable<MetadataQuery>(
       metadata_server_name_, std::string(MetadataQuery::kIPv6Attribute),
       &pollent_,
-      [resolver = static_cast<RefCountedPtr<GoogleCloud2ProdResolver>>(Ref())](
+      [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
           std::string /* attribute */,
           absl::StatusOr<std::string> result) mutable {
         resolver->work_serializer_->Run(

data/src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -105,10 +105,9 @@ void PollingResolver::ShutdownLocked() {
 }
 
 void PollingResolver::ScheduleNextResolutionTimer(const Duration& timeout) {
-  RefCountedPtr<PollingResolver> self = Ref();
   next_resolution_timer_handle_ =
       channel_args_.GetObject<EventEngine>()->RunAfter(
-          timeout, [self = std::move(self)]() mutable {
+          timeout, [self = RefAsSubclass<PollingResolver>()]() mutable {
             ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();
@@ -174,12 +173,11 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
               result.resolution_note.c_str());
     }
     GPR_ASSERT(result.result_health_callback == nullptr);
-    RefCountedPtr<PollingResolver> self =
-        Ref(DEBUG_LOCATION, "result_health_callback");
-    result.result_health_callback = [self =
-                                         std::move(self)](absl::Status status) {
-      self->GetResultStatus(std::move(status));
-    };
+    result.result_health_callback =
+        [self = RefAsSubclass<PollingResolver>(
+             DEBUG_LOCATION, "result_health_callback")](absl::Status status) {
+          self->GetResultStatus(std::move(status));
+        };
     result_status_state_ = ResultStatusState::kResultHealthCallbackPending;
     result_handler_->ReportResult(std::move(result));
   }