Automated fix for refs/heads/test_849246236

src/core/client_channel/client_channel.cc

@@ -491,7 +491,7 @@ class ClientChannel::ClientChannelControlHelper
         args, per_address_args, client_channel_->subchannel_pool_,
         client_channel_->default_authority_);
     // Create subchannel.
-    auto uri = grpc_core::URI::Parse(address);
+    auto uri = URI::Parse(address);
     if (!uri.ok()) {
       LOG(ERROR) << "Failed to parse address URI: " << address;
       return nullptr;

src/core/client_channel/client_channel_filter.cc

@@ -906,7 +906,7 @@ class ClientChannelFilter::ClientChannelControlHelper final
         args, per_address_args, chand_->subchannel_pool_,
         chand_->default_authority_);
     // Create subchannel.
-    auto uri = grpc_core::URI::Parse(address_uri);
+    auto uri = URI::Parse(address_uri);
     if (!uri.ok()) {
       LOG(ERROR) << "Failed to parse address URI: " << address_uri;
       return nullptr;

src/core/load_balancing/endpoint_list.h

@@ -157,8 +157,8 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
 
     // Called to create a subchannel.  Subclasses may override.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& per_address_args, const ChannelArgs& args);
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args);
 
     RefCountedPtr<EndpointList> endpoint_list_;
 

src/core/load_balancing/grpclb/grpclb.cc

@@ -453,8 +453,8 @@ class GrpcLb final : public LoadBalancingPolicy {
         : ParentOwningDelegatingChannelControlHelper(std::move(parent)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& per_address_args, const ChannelArgs& args) override;
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
     void RequestReresolution() override;

src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -379,21 +379,21 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     bool counting_enabled_;
   };
 
-class Helper final
-    : public ParentOwningDelegatingChannelControlHelper<OutlierDetectionLb> {
- public:
-  explicit Helper(RefCountedPtr<OutlierDetectionLb> outlier_detection_policy)
-      : ParentOwningDelegatingChannelControlHelper(
-            std::move(outlier_detection_policy)) {}
-
-  RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      const std::string& address, const ChannelArgs& per_address_args,
-      const ChannelArgs& args) override;
-  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
-                   // ignored.  The child will be re-created and will report
-                   // its own new picker.
-                   RefCountedPtr<SubchannelPicker> picker) override;
-};
+  class Helper final
+      : public ParentOwningDelegatingChannelControlHelper<OutlierDetectionLb> {
+   public:
+    explicit Helper(RefCountedPtr<OutlierDetectionLb> outlier_detection_policy)
+        : ParentOwningDelegatingChannelControlHelper(
+              std::move(outlier_detection_policy)) {}
+
+    RefCountedPtr<SubchannelInterface> CreateSubchannel(
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args) override;
+    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
+                     // ignored.  The child will be re-created and will report
+                     // its own new picker.
+                     RefCountedPtr<SubchannelPicker> picker) override;
+  };
 
   class EjectionTimer final : public InternallyRefCounted<EjectionTimer> {
    public:
@@ -435,8 +435,7 @@ class Helper final
   RefCountedPtr<SubchannelPicker> picker_;
   std::map<EndpointAddressSet, RefCountedPtr<EndpointState>>
       endpoint_state_map_;
-  std::map<std::string, RefCountedPtr<SubchannelState>,
-           StringLessThan>
+  std::map<std::string, RefCountedPtr<SubchannelState>, StringLessThan>
       subchannel_state_map_;
   OrphanablePtr<EjectionTimer> ejection_timer_;
 };
@@ -746,8 +745,9 @@ OrphanablePtr<LoadBalancingPolicy> OutlierDetectionLb::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<OutlierDetectionLb::Helper>(
-      RefAsSubclass<OutlierDetectionLb>(DEBUG_LOCATION, "Helper"));
+  lb_policy_args.channel_control_helper =
+      std::make_unique<OutlierDetectionLb::Helper>(
+          RefAsSubclass<OutlierDetectionLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &outlier_detection_lb_trace);

src/core/load_balancing/pick_first/pick_first.cc

@@ -14,9 +14,7 @@
 // limitations under the License.
 //
 
-#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/load_balancing/pick_first/pick_first.h"
-#include "src/core/util/uri.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/channel_arg_names.h>
@@ -34,6 +32,7 @@
 #include <vector>
 
 #include "src/core/config/core_configuration.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/debug/trace.h"
@@ -58,6 +57,7 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
+#include "src/core/util/uri.h"
 #include "src/core/util/useful.h"
 #include "src/core/util/work_serializer.h"
 #include "absl/algorithm/container.h"
@@ -484,7 +484,7 @@ void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
 }
 
 std::string GetAddressFamily(absl::string_view address_uri) {
-  auto uri = grpc_core::URI::Parse(address_uri);
+  auto uri = URI::Parse(address_uri);
   if (!uri.ok()) {
     return "other";
   }

src/core/load_balancing/ring_hash/ring_hash.cc

@@ -34,6 +34,7 @@
 
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.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/debug/trace.h"
@@ -69,7 +70,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "src/core/lib/address_utils/parse_address.h"
 
 namespace grpc_core {
 
@@ -455,10 +455,10 @@ RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
     if (hash_key.has_value()) {
       endpoint_weight.hash_key = std::string(*hash_key);
     } else {
-      auto uri = grpc_core::URI::Parse(endpoint.addresses().front());
+      auto uri = URI::Parse(endpoint.addresses().front());
       CHECK(uri.ok()) << "Failed to parse URI: " << endpoint.addresses().front()
                       << " with status: " << uri.status();
-                      grpc_resolved_address resolved_addr;
+      grpc_resolved_address resolved_addr;
       CHECK(grpc_parse_uri(*uri, &resolved_addr))
           << "Failed to convert URI to resolved address: "
           << endpoint.addresses().front();

src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -265,8 +265,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
       };
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          const std::string& address,
-          const ChannelArgs& per_address_args,
+          const std::string& address, const ChannelArgs& per_address_args,
           const ChannelArgs& args) override;
 
       // Called when the child policy reports a connectivity state update.

src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -260,8 +260,8 @@ class XdsClusterImplLb final : public LoadBalancingPolicy {
               std::move(xds_cluster_impl_policy)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& per_address_args, const ChannelArgs& args) override;
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
   };

src/core/load_balancing/xds/xds_override_host.cc

@@ -345,8 +345,8 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
               std::move(xds_override_host_policy)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& per_address_args, const ChannelArgs& args) override;
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      RefCountedPtr<SubchannelPicker> picker) override;
   };
@@ -805,7 +805,7 @@ void XdsOverrideHostLb::UpdateAddressMap(
     std::vector<std::string> addresses;
     addresses.reserve(endpoint.addresses().size());
     for (const auto& address : endpoint.addresses()) {
-      addresses.push_back(std::move(address));
+      addresses.push_back(address);
     }
     absl::Span<const std::string> addresses_span = addresses;
     for (size_t i = 0; i < addresses.size(); ++i) {
@@ -873,8 +873,7 @@ void XdsOverrideHostLb::UpdateAddressMap(
 
 RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
 XdsOverrideHostLb::AdoptSubchannel(
-    const std::string& address,
-    RefCountedPtr<SubchannelInterface> subchannel) {
+    const std::string& address, RefCountedPtr<SubchannelInterface> subchannel) {
   auto wrapper = MakeRefCounted<SubchannelWrapper>(
       std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
   // Drop ref to previously owned subchannel (if any) after releasing

src/core/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -58,10 +58,10 @@
 #include <address_sorting/address_sorting.h>
 
 #include "src/core/config/config_vars.h"
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/load_balancing/grpclb/grpclb_balancer_addresses.h"
 #include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/resolver/endpoint_addresses.h"
@@ -531,7 +531,7 @@ class AresDNSResolver final : public DNSResolver {
         resolved_addresses.reserve(addresses_->size());
         for (const auto& server_address : *addresses_) {
           grpc_resolved_address resolved_address;
-          auto uri = grpc_core::URI::Parse(server_address.address());
+          auto uri = URI::Parse(server_address.address());
           if (!uri.ok() || !grpc_parse_uri(*uri, &resolved_address)) {
             LOG(ERROR) << "Failed to parse address: "
                        << server_address.address();
@@ -590,7 +590,7 @@ class AresDNSResolver final : public DNSResolver {
       if (balancer_addresses_ != nullptr) {
         resolved_addresses.reserve(balancer_addresses_->size());
         for (const auto& server_address : *balancer_addresses_) {
-          auto uri = grpc_core::URI::Parse(server_address.address());
+          auto uri = URI::Parse(server_address.address());
           grpc_resolved_address resolved_address;
           if (!uri.ok() || !grpc_parse_uri(*uri, &resolved_address)) {
             LOG(ERROR) << "Failed to parse address: "

src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -419,8 +419,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
         errors_.AddError(uri.status().message());
         continue;
       }
-      balancer_addresses_.emplace_back(*uri,
-                                       srv_channel_args);
+      balancer_addresses_.emplace_back(*uri, srv_channel_args);
     }
   }
   result = OnResolvedLocked();

src/core/resolver/endpoint_addresses.cc

@@ -42,8 +42,8 @@ EndpointAddresses::EndpointAddresses(const std::string& address,
                                      const ChannelArgs& args)
     : addresses_(1, address), args_(args) {}
 
-EndpointAddresses::EndpointAddresses(
-    std::vector<std::string> addresses, const ChannelArgs& args)
+EndpointAddresses::EndpointAddresses(std::vector<std::string> addresses,
+                                     const ChannelArgs& args)
     : addresses_(std::move(addresses)), args_(args) {
   GRPC_CHECK(!addresses_.empty());
 }
@@ -88,9 +88,8 @@ std::string EndpointAddresses::ToString() const {
   return absl::StrJoin(parts, " ");
 }
 
-bool StringLessThan::operator()(
-    const std::string& str1,
-    const std::string& str2) const {
+bool StringLessThan::operator()(const std::string& str1,
+                                const std::string& str2) const {
   return str1 < str2;
 }
 

src/core/resolver/endpoint_addresses.h

@@ -83,9 +83,7 @@ class EndpointAddresses final {
   // TODO(roth): Remove when all callers have been updated.
   const std::string& address() const { return addresses_[0]; }
 
-  const std::vector<std::string>& addresses() const {
-    return addresses_;
-  }
+  const std::vector<std::string>& addresses() const { return addresses_; }
   const ChannelArgs& args() const { return args_; }
 
   // TODO(ctiller): Prior to making this a public API we should ensure that the
@@ -101,14 +99,12 @@ class EndpointAddresses final {
 using EndpointAddressesList = std::vector<EndpointAddresses>;
 
 struct StringLessThan {
-  bool operator()(const std::string& str1,
-                  const std::string& str2) const;
+  bool operator()(const std::string& str1, const std::string& str2) const;
 };
 
 class EndpointAddressSet final {
  public:
-  explicit EndpointAddressSet(
-      const std::vector<std::string>& addresses)
+  explicit EndpointAddressSet(const std::vector<std::string>& addresses)
       : addresses_(addresses.begin(), addresses.end()) {}
 
   bool operator==(const EndpointAddressSet& other) const;

src/core/xds/grpc/xds_endpoint_parser.cc

@@ -227,10 +227,9 @@ struct ParsedLocality {
 };
 
 struct StringLessThan {
-  bool operator()(const std::string& str1,
-                  const std::string& str2) const {
-    auto uri_a = grpc_core::URI::Parse(str1);
-    auto uri_b = grpc_core::URI::Parse(str2);
+  bool operator()(const std::string& str1, const std::string& str2) const {
+    auto uri_a = URI::Parse(str1);
+    auto uri_b = URI::Parse(str2);
     if (!uri_a.ok() || !uri_b.ok()) {
       return str1 < str2;
     }
@@ -243,8 +242,7 @@ struct StringLessThan {
     return memcmp(addr_a.addr, addr_b.addr, addr_a.len) < 0;
   }
 };
-using AddressSet =
-    std::set<std::string, StringLessThan>;
+using AddressSet = std::set<std::string, StringLessThan>;
 
 std::optional<ParsedLocality> LocalityParse(
     const XdsResourceType::DecodeContext& context,
@@ -305,8 +303,8 @@ std::optional<ParsedLocality> LocalityParse(
       for (const auto& address : endpoint->addresses()) {
         bool inserted = address_set->insert(address).second;
         if (!inserted) {
-          errors->AddError(absl::StrCat(
-              "duplicate endpoint address \"", address, "\""));
+          errors->AddError(
+              absl::StrCat("duplicate endpoint address \"", address, "\""));
         }
       }
       parsed_locality.locality.endpoints.push_back(std::move(*endpoint));

test/core/load_balancing/bm_picker.cc

@@ -139,8 +139,8 @@ class BenchmarkHelper : public std::enable_shared_from_this<BenchmarkHelper> {
     explicit LbHelper(BenchmarkHelper* helper) : helper_(helper) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& per_address_args, const ChannelArgs& args) override {
+        const std::string& address, const ChannelArgs& per_address_args,
+        const ChannelArgs& args) override {
       return MakeRefCounted<SubchannelFake>(helper_);
     }
 

test/core/load_balancing/lb_policy_test_lib.h

@@ -512,17 +512,17 @@ class LoadBalancingPolicyTest : public ::testing::Test {
     }
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const std::string& address,
-        const ChannelArgs& /*per_address_args*/,
+        const std::string& address, const ChannelArgs& /*per_address_args*/,
         const ChannelArgs& args) override {
       // TODO(roth): Need to use per_address_args here.
-      SubchannelKey key(MakeAddress(address), args.RemoveAllKeysWithPrefix(
-                                              GRPC_ARG_NO_SUBCHANNEL_PREFIX));
+      SubchannelKey key(
+          MakeAddress(address),
+          args.RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX));
       auto it = test_->subchannel_pool_.find(key);
       if (it == test_->subchannel_pool_.end()) {
         it = test_->subchannel_pool_
                  .emplace(std::piecewise_construct, std::forward_as_tuple(key),
-                          std::forward_as_tuple(std::move(address), test_))
+                          std::forward_as_tuple(address, test_))
                  .first;
       }
       return it->second.CreateSubchannel();