simplify

src/core/load_balancing/endpoint_list.h

@@ -62,12 +62,9 @@ class MyEndpointList : public EndpointList {
     Init(endpoints, args,
          [&](RefCountedPtr<MyEndpointList> endpoint_list,
              const EndpointAddresses& addresses, const ChannelArgs& args) {
-           absl::Status status;
-           auto endpoint = MakeOrphanable<MyEndpoint>(
+           return MakeOrphanable<MyEndpoint>(
                std::move(endpoint_list), addresses, args,
-               policy<MyLbPolicy>()->work_serializer(), &status);
-           if (!error.empty()) errors->push_back(status.ToString());
-           return endpoint;
+               policy<MyLbPolicy>()->work_serializer(), errors);
          });
   }
 
@@ -75,11 +72,15 @@ class MyEndpointList : public EndpointList {
   class MyEndpoint : public Endpoint {
    public:
     MyEndpoint(RefCountedPtr<MyEndpointList> endpoint_list,
-               const EndpointAddresses& address, const ChannelArgs& args,
+               const EndpointAddresses& addresses, const ChannelArgs& args,
                std::shared_ptr<WorkSerializer> work_serializer,
-               absl::Status* status)
+               std::vector<std::string>* errors)
         : Endpoint(std::move(endpoint_list)) {
-      *status = Init(addresses, args, std::move(work_serializer));
+      absl::Status status = Init(addresses, args, std::move(work_serializer));
+      if (!status.ok()) {
+        errors->emplace_back(absl::StrCat(
+            "endpoint ", addresses.ToString(), ": ", status.ToString()));
+      }
     }
 
    private:

src/core/load_balancing/round_robin/round_robin.cc

@@ -81,15 +81,9 @@ class RoundRobin final : public LoadBalancingPolicy {
       Init(endpoints, args,
            [&](RefCountedPtr<EndpointList> endpoint_list,
                const EndpointAddresses& addresses, const ChannelArgs& args) {
-             absl::Status status;
-             auto endpoint = MakeOrphanable<RoundRobinEndpoint>(
+             return MakeOrphanable<RoundRobinEndpoint>(
                  std::move(endpoint_list), addresses, args,
-                 policy<RoundRobin>()->work_serializer(), &status);
-             if (!status.ok()) {
-               errors->emplace_back(absl::StrCat(
-                   "endpoint ", addresses.ToString(), ": ", status.ToString()));
-             }
-             return endpoint;
+                 policy<RoundRobin>()->work_serializer(), errors);
            });
     }
 
@@ -100,9 +94,13 @@ class RoundRobin final : public LoadBalancingPolicy {
                          const EndpointAddresses& addresses,
                          const ChannelArgs& args,
                          std::shared_ptr<WorkSerializer> work_serializer,
-                         absl::Status* status)
+                         std::vector<std::string>* errors)
           : Endpoint(std::move(endpoint_list)) {
-        *status = Init(addresses, args, std::move(work_serializer));
+        absl::Status status = Init(addresses, args, std::move(work_serializer));
+        if (!status.ok()) {
+          errors->emplace_back(absl::StrCat("endpoint ", addresses.ToString(),
+                                            ": ", status.ToString()));
+        }
       }
 
      private:

src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -222,11 +222,15 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
       WrrEndpoint(RefCountedPtr<EndpointList> endpoint_list,
                   const EndpointAddresses& addresses, const ChannelArgs& args,
                   std::shared_ptr<WorkSerializer> work_serializer,
-                  absl::Status* status)
+                  std::vector<std::string>* errors)
           : Endpoint(std::move(endpoint_list)),
             weight_(policy<WeightedRoundRobin>()->GetOrCreateWeight(
                 addresses.addresses())) {
-        *status = Init(addresses, args, std::move(work_serializer));
+        absl::Status status = Init(addresses, args, std::move(work_serializer));
+        if (!status.ok()) {
+          errors->emplace_back(absl::StrCat("endpoint ", addresses.ToString(),
+                                            ": ", status.ToString()));
+        }
       }
 
       RefCountedPtr<EndpointWeight> weight() const { return weight_; }
@@ -270,15 +274,9 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
       Init(endpoints, args,
            [&](RefCountedPtr<EndpointList> endpoint_list,
                const EndpointAddresses& addresses, const ChannelArgs& args) {
-             absl::Status status;
-             auto endpoint = MakeOrphanable<WrrEndpoint>(
+             return MakeOrphanable<WrrEndpoint>(
                  std::move(endpoint_list), addresses, args,
-                 policy<WeightedRoundRobin>()->work_serializer(), &status);
-             if (!status.ok()) {
-               errors->emplace_back(absl::StrCat(
-                   "endpoint ", addresses.ToString(), ": ", status.ToString()));
-             }
-             return endpoint;
+                 policy<WeightedRoundRobin>()->work_serializer(), errors);
            });
     }