grpc 1.26.0 → 1.28.0

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

@@ -28,16 +28,38 @@
 
 namespace grpc_core {
 
-grpc_grpclb_request* grpc_grpclb_request_create(const char* lb_service_name,
-                                                upb_arena* arena) {
-  grpc_grpclb_request* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
+bool GrpcLbServer::operator==(const GrpcLbServer& other) const {
+  if (ip_size != other.ip_size) return false;
+  int r = memcmp(ip_addr, other.ip_addr, ip_size);
+  if (r != 0) return false;
+  if (port != other.port) return false;
+  r = strncmp(load_balance_token, other.load_balance_token,
+              sizeof(load_balance_token));
+  if (r != 0) return false;
+  return drop == other.drop;
+}
+
+namespace {
+
+grpc_slice grpc_grpclb_request_encode(
+    const grpc_lb_v1_LoadBalanceRequest* request, upb_arena* arena) {
+  size_t buf_length;
+  char* buf =
+      grpc_lb_v1_LoadBalanceRequest_serialize(request, arena, &buf_length);
+  return grpc_slice_from_copied_buffer(buf, buf_length);
+}
+
+}  // namespace
+
+grpc_slice GrpcLbRequestCreate(const char* lb_service_name, upb_arena* arena) {
+  grpc_lb_v1_LoadBalanceRequest* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
   grpc_lb_v1_InitialLoadBalanceRequest* initial_request =
       grpc_lb_v1_LoadBalanceRequest_mutable_initial_request(req, arena);
   size_t name_len =
       GPR_MIN(strlen(lb_service_name), GRPC_GRPCLB_SERVICE_NAME_MAX_LENGTH);
   grpc_lb_v1_InitialLoadBalanceRequest_set_name(
       initial_request, upb_strview_make(lb_service_name, name_len));
-  return req;
+  return grpc_grpclb_request_encode(req, arena);
 }
 
 namespace {
@@ -50,23 +72,18 @@ void google_protobuf_Timestamp_assign(google_protobuf_Timestamp* timestamp,
 
 }  // namespace
 
-grpc_grpclb_request* grpc_grpclb_load_report_request_create(
-    GrpcLbClientStats* client_stats, upb_arena* arena) {
-  grpc_grpclb_request* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
+grpc_slice GrpcLbLoadReportRequestCreate(
+    int64_t num_calls_started, int64_t num_calls_finished,
+    int64_t num_calls_finished_with_client_failed_to_send,
+    int64_t num_calls_finished_known_received,
+    const GrpcLbClientStats::DroppedCallCounts* drop_token_counts,
+    upb_arena* arena) {
+  grpc_lb_v1_LoadBalanceRequest* req = grpc_lb_v1_LoadBalanceRequest_new(arena);
   grpc_lb_v1_ClientStats* req_stats =
       grpc_lb_v1_LoadBalanceRequest_mutable_client_stats(req, arena);
   google_protobuf_Timestamp_assign(
       grpc_lb_v1_ClientStats_mutable_timestamp(req_stats, arena),
       gpr_now(GPR_CLOCK_REALTIME));
-
-  int64_t num_calls_started;
-  int64_t num_calls_finished;
-  int64_t num_calls_finished_with_client_failed_to_send;
-  int64_t num_calls_finished_known_received;
-  std::unique_ptr<GrpcLbClientStats::DroppedCallCounts> drop_token_counts;
-  client_stats->Get(&num_calls_started, &num_calls_finished,
-                    &num_calls_finished_with_client_failed_to_send,
-                    &num_calls_finished_known_received, &drop_token_counts);
   grpc_lb_v1_ClientStats_set_num_calls_started(req_stats, num_calls_started);
   grpc_lb_v1_ClientStats_set_num_calls_finished(req_stats, num_calls_finished);
   grpc_lb_v1_ClientStats_set_num_calls_finished_with_client_failed_to_send(
@@ -75,152 +92,102 @@ grpc_grpclb_request* grpc_grpclb_load_report_request_create(
       req_stats, num_calls_finished_known_received);
   if (drop_token_counts != nullptr) {
     for (size_t i = 0; i < drop_token_counts->size(); ++i) {
-      GrpcLbClientStats::DropTokenCount& cur = (*drop_token_counts)[i];
+      const GrpcLbClientStats::DropTokenCount& cur = (*drop_token_counts)[i];
       grpc_lb_v1_ClientStatsPerToken* cur_msg =
           grpc_lb_v1_ClientStats_add_calls_finished_with_drop(req_stats, arena);
-
       const size_t token_len = strlen(cur.token.get());
       char* token = reinterpret_cast<char*>(upb_arena_malloc(arena, token_len));
       memcpy(token, cur.token.get(), token_len);
-
       grpc_lb_v1_ClientStatsPerToken_set_load_balance_token(
           cur_msg, upb_strview_make(token, token_len));
       grpc_lb_v1_ClientStatsPerToken_set_num_calls(cur_msg, cur.count);
     }
   }
-  return req;
+  return grpc_grpclb_request_encode(req, arena);
 }
 
-grpc_slice grpc_grpclb_request_encode(const grpc_grpclb_request* request,
-                                      upb_arena* arena) {
-  size_t buf_length;
-  char* buf =
-      grpc_lb_v1_LoadBalanceRequest_serialize(request, arena, &buf_length);
-  return grpc_slice_from_copied_buffer(buf, buf_length);
-}
-
-const grpc_grpclb_initial_response* grpc_grpclb_initial_response_parse(
-    const grpc_slice& encoded_grpc_grpclb_response, upb_arena* arena) {
-  grpc_lb_v1_LoadBalanceResponse* response =
-      grpc_lb_v1_LoadBalanceResponse_parse(
-          reinterpret_cast<const char*>(
-              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
-          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena);
-  if (response == nullptr) {
-    gpr_log(GPR_ERROR, "grpc_lb_v1_LoadBalanceResponse parse error");
-    return nullptr;
-  }
-  return grpc_lb_v1_LoadBalanceResponse_initial_response(response);
-}
+namespace {
 
-grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
-    const grpc_slice& encoded_grpc_grpclb_response) {
-  upb::Arena arena;
-  grpc_lb_v1_LoadBalanceResponse* response =
-      grpc_lb_v1_LoadBalanceResponse_parse(
-          reinterpret_cast<const char*>(
-              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
-          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena.ptr());
-  if (response == nullptr) {
-    gpr_log(GPR_ERROR, "grpc_lb_v1_LoadBalanceResponse parse error");
-    return nullptr;
-  }
-  grpc_grpclb_serverlist* server_list = static_cast<grpc_grpclb_serverlist*>(
-      gpr_zalloc(sizeof(grpc_grpclb_serverlist)));
-  // First pass: count number of servers.
+bool ParseServerList(const grpc_lb_v1_LoadBalanceResponse& response,
+                     std::vector<GrpcLbServer>* server_list) {
+  // Determine the number of servers.
   const grpc_lb_v1_ServerList* server_list_msg =
-      grpc_lb_v1_LoadBalanceResponse_server_list(response);
+      grpc_lb_v1_LoadBalanceResponse_server_list(&response);
+  if (server_list_msg == nullptr) return false;
   size_t server_count = 0;
-  const grpc_lb_v1_Server* const* servers = nullptr;
-  if (server_list_msg != nullptr) {
-    servers = grpc_lb_v1_ServerList_servers(server_list_msg, &server_count);
-  }
-  // Second pass: populate servers.
+  const grpc_lb_v1_Server* const* servers =
+      grpc_lb_v1_ServerList_servers(server_list_msg, &server_count);
+  // Populate servers.
   if (server_count > 0) {
-    server_list->servers = static_cast<grpc_grpclb_server**>(
-        gpr_zalloc(sizeof(grpc_grpclb_server*) * server_count));
-    server_list->num_servers = server_count;
+    server_list->reserve(server_count);
     for (size_t i = 0; i < server_count; ++i) {
-      grpc_grpclb_server* cur = server_list->servers[i] =
-          static_cast<grpc_grpclb_server*>(
-              gpr_zalloc(sizeof(grpc_grpclb_server)));
+      GrpcLbServer& cur = *server_list->emplace(server_list->end());
       upb_strview address = grpc_lb_v1_Server_ip_address(servers[i]);
       if (address.size == 0) {
         ;  // Nothing to do because cur->ip_address is an empty string.
       } else if (address.size <= GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE) {
-        cur->ip_address.size = static_cast<int32_t>(address.size);
-        memcpy(cur->ip_address.data, address.data, address.size);
+        cur.ip_size = static_cast<int32_t>(address.size);
+        memcpy(cur.ip_addr, address.data, address.size);
       }
-      cur->port = grpc_lb_v1_Server_port(servers[i]);
+      cur.port = grpc_lb_v1_Server_port(servers[i]);
       upb_strview token = grpc_lb_v1_Server_load_balance_token(servers[i]);
       if (token.size == 0) {
         ;  // Nothing to do because cur->load_balance_token is an empty string.
       } else if (token.size <= GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE) {
-        memcpy(cur->load_balance_token, token.data, token.size);
+        memcpy(cur.load_balance_token, token.data, token.size);
       } else {
         gpr_log(GPR_ERROR,
                 "grpc_lb_v1_LoadBalanceResponse has too long token. len=%zu",
                 token.size);
       }
-      cur->drop = grpc_lb_v1_Server_drop(servers[i]);
+      cur.drop = grpc_lb_v1_Server_drop(servers[i]);
     }
   }
-  return server_list;
+  return true;
 }
 
-void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist* serverlist) {
-  if (serverlist == nullptr) {
-    return;
-  }
-  for (size_t i = 0; i < serverlist->num_servers; i++) {
-    gpr_free(serverlist->servers[i]);
-  }
-  gpr_free(serverlist->servers);
-  gpr_free(serverlist);
+grpc_millis grpc_grpclb_duration_to_millis(
+    const google_protobuf_Duration* duration_pb) {
+  return static_cast<grpc_millis>(
+      (google_protobuf_Duration_seconds(duration_pb) * GPR_MS_PER_SEC) +
+      (google_protobuf_Duration_nanos(duration_pb) / GPR_NS_PER_MS));
 }
 
-grpc_grpclb_serverlist* grpc_grpclb_serverlist_copy(
-    const grpc_grpclb_serverlist* server_list) {
-  grpc_grpclb_serverlist* copy = static_cast<grpc_grpclb_serverlist*>(
-      gpr_zalloc(sizeof(grpc_grpclb_serverlist)));
-  copy->num_servers = server_list->num_servers;
-  copy->servers = static_cast<grpc_grpclb_server**>(
-      gpr_malloc(sizeof(grpc_grpclb_server*) * server_list->num_servers));
-  for (size_t i = 0; i < server_list->num_servers; i++) {
-    copy->servers[i] = static_cast<grpc_grpclb_server*>(
-        gpr_malloc(sizeof(grpc_grpclb_server)));
-    memcpy(copy->servers[i], server_list->servers[i],
-           sizeof(grpc_grpclb_server));
-  }
-  return copy;
-}
+}  // namespace
 
-bool grpc_grpclb_serverlist_equals(const grpc_grpclb_serverlist* lhs,
-                                   const grpc_grpclb_serverlist* rhs) {
-  if (lhs == nullptr || rhs == nullptr) {
-    return false;
-  }
-  if (lhs->num_servers != rhs->num_servers) {
-    return false;
+bool GrpcLbResponseParse(const grpc_slice& encoded_grpc_grpclb_response,
+                         upb_arena* arena, GrpcLbResponse* result) {
+  grpc_lb_v1_LoadBalanceResponse* response =
+      grpc_lb_v1_LoadBalanceResponse_parse(
+          reinterpret_cast<const char*>(
+              GRPC_SLICE_START_PTR(encoded_grpc_grpclb_response)),
+          GRPC_SLICE_LENGTH(encoded_grpc_grpclb_response), arena);
+  // Handle serverlist responses.
+  if (ParseServerList(*response, &result->serverlist)) {
+    result->type = result->SERVERLIST;
+    return true;
   }
-  for (size_t i = 0; i < lhs->num_servers; i++) {
-    if (!grpc_grpclb_server_equals(lhs->servers[i], rhs->servers[i])) {
-      return false;
+  // Handle initial responses.
+  auto* initial_response =
+      grpc_lb_v1_LoadBalanceResponse_initial_response(response);
+  if (initial_response != nullptr) {
+    result->type = result->INITIAL;
+    const google_protobuf_Duration* client_stats_report_interval =
+        grpc_lb_v1_InitialLoadBalanceResponse_client_stats_report_interval(
+            initial_response);
+    if (client_stats_report_interval != nullptr) {
+      result->client_stats_report_interval =
+          grpc_grpclb_duration_to_millis(client_stats_report_interval);
     }
+    return true;
   }
-  return true;
-}
-
-bool grpc_grpclb_server_equals(const grpc_grpclb_server* lhs,
-                               const grpc_grpclb_server* rhs) {
-  return memcmp(lhs, rhs, sizeof(grpc_grpclb_server)) == 0;
-}
-
-grpc_millis grpc_grpclb_duration_to_millis(
-    const grpc_grpclb_duration* duration_pb) {
-  return static_cast<grpc_millis>(
-      google_protobuf_Duration_seconds(duration_pb) * GPR_MS_PER_SEC +
-      google_protobuf_Duration_nanos(duration_pb) / GPR_NS_PER_MS);
+  // Handle fallback.
+  if (grpc_lb_v1_LoadBalanceResponse_has_fallback_response(response)) {
+    result->type = result->FALLBACK;
+    return true;
+  }
+  // Unknown response type.
+  return false;
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <vector>
+
 #include <grpc/slice_buffer.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h"
@@ -33,69 +35,38 @@
 
 namespace grpc_core {
 
-typedef grpc_lb_v1_LoadBalanceRequest grpc_grpclb_request;
-typedef grpc_lb_v1_LoadBalanceResponse grpc_grpclb_response;
-typedef grpc_lb_v1_InitialLoadBalanceResponse grpc_grpclb_initial_response;
-typedef google_protobuf_Duration grpc_grpclb_duration;
-typedef google_protobuf_Timestamp grpc_grpclb_timestamp;
-
-typedef struct {
-  int32_t size;
-  char data[GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE];
-} grpc_grpclb_server_ip_address;
-
 // Contains server information. When the drop field is not true, use the other
 // fields.
-typedef struct {
-  grpc_grpclb_server_ip_address ip_address;
+struct GrpcLbServer {
+  int32_t ip_size;
+  char ip_addr[GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE];
   int32_t port;
   char load_balance_token[GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE];
   bool drop;
-} grpc_grpclb_server;
-
-typedef struct {
-  grpc_grpclb_server** servers;
-  size_t num_servers;
-} grpc_grpclb_serverlist;
-
-/**
- * Create a request for a gRPC LB service under \a lb_service_name.
- * \a lb_service_name should be alive when returned request is being used.
- */
-grpc_grpclb_request* grpc_grpclb_request_create(const char* lb_service_name,
-                                                upb_arena* arena);
-grpc_grpclb_request* grpc_grpclb_load_report_request_create(
-    grpc_core::GrpcLbClientStats* client_stats, upb_arena* arena);
-
-/** Protocol Buffers v3-encode \a request */
-grpc_slice grpc_grpclb_request_encode(const grpc_grpclb_request* request,
-                                      upb_arena* arena);
-
-/** Parse (ie, decode) the bytes in \a encoded_grpc_grpclb_response as a \a
- * grpc_grpclb_initial_response */
-const grpc_grpclb_initial_response* grpc_grpclb_initial_response_parse(
-    const grpc_slice& encoded_grpc_grpclb_response, upb_arena* arena);
-
-/** Parse the list of servers from an encoded \a grpc_grpclb_response */
-grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
-    const grpc_slice& encoded_grpc_grpclb_response);
-
-/** Return a copy of \a sl. The caller is responsible for calling \a
- * grpc_grpclb_destroy_serverlist on the returned copy. */
-grpc_grpclb_serverlist* grpc_grpclb_serverlist_copy(
-    const grpc_grpclb_serverlist* sl);
-
-bool grpc_grpclb_serverlist_equals(const grpc_grpclb_serverlist* lhs,
-                                   const grpc_grpclb_serverlist* rhs);
-
-bool grpc_grpclb_server_equals(const grpc_grpclb_server* lhs,
-                               const grpc_grpclb_server* rhs);
-
-/** Destroy \a serverlist */
-void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist* serverlist);
 
-grpc_millis grpc_grpclb_duration_to_millis(
-    const grpc_grpclb_duration* duration_pb);
+  bool operator==(const GrpcLbServer& other) const;
+};
+
+struct GrpcLbResponse {
+  enum { INITIAL, SERVERLIST, FALLBACK } type;
+  grpc_millis client_stats_report_interval = 0;
+  std::vector<GrpcLbServer> serverlist;
+};
+
+// Creates a serialized grpclb request.
+grpc_slice GrpcLbRequestCreate(const char* lb_service_name, upb_arena* arena);
+
+// Creates a serialized grpclb load report request.
+grpc_slice GrpcLbLoadReportRequestCreate(
+    int64_t num_calls_started, int64_t num_calls_finished,
+    int64_t num_calls_finished_with_client_failed_to_send,
+    int64_t num_calls_finished_known_received,
+    const GrpcLbClientStats::DroppedCallCounts* drop_token_counts,
+    upb_arena* arena);
+
+// Deserialize a grpclb response.
+bool GrpcLbResponseParse(const grpc_slice& serialized_response,
+                         upb_arena* arena, GrpcLbResponse* response);
 
 }  // namespace grpc_core
 

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

@@ -201,7 +201,7 @@ void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
                            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(error));
+        absl::make_unique<TransientFailurePicker>(error));
     return;
   }
   // If one of the subchannels in the new list is already in state
@@ -319,11 +319,11 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
             GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
         p->channel_control_helper()->UpdateState(
             GRPC_CHANNEL_TRANSIENT_FAILURE,
-            MakeUnique<TransientFailurePicker>(error));
+            absl::make_unique<TransientFailurePicker>(error));
       } else {
         p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_CONNECTING,
-            MakeUnique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+            GRPC_CHANNEL_CONNECTING, absl::make_unique<QueuePicker>(p->Ref(
+                                         DEBUG_LOCATION, "QueuePicker")));
       }
     } else {
       if (connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
@@ -338,19 +338,20 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
         p->selected_ = nullptr;
         p->subchannel_list_.reset();
         p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_IDLE,
-            MakeUnique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+            GRPC_CHANNEL_IDLE, absl::make_unique<QueuePicker>(
+                                   p->Ref(DEBUG_LOCATION, "QueuePicker")));
       } else {
         // This is unlikely but can happen when a subchannel has been asked
         // to reconnect by a different channel and this channel has dropped
         // some connectivity state notifications.
         if (connectivity_state == GRPC_CHANNEL_READY) {
           p->channel_control_helper()->UpdateState(
-              GRPC_CHANNEL_READY, MakeUnique<Picker>(subchannel()->Ref()));
+              GRPC_CHANNEL_READY,
+              absl::make_unique<Picker>(subchannel()->Ref()));
         } else {  // CONNECTING
           p->channel_control_helper()->UpdateState(
-              connectivity_state,
-              MakeUnique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+              connectivity_state, absl::make_unique<QueuePicker>(
+                                      p->Ref(DEBUG_LOCATION, "QueuePicker")));
         }
       }
     }
@@ -394,7 +395,7 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
               GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
           p->channel_control_helper()->UpdateState(
               GRPC_CHANNEL_TRANSIENT_FAILURE,
-              MakeUnique<TransientFailurePicker>(error));
+              absl::make_unique<TransientFailurePicker>(error));
         }
       }
       sd->CheckConnectivityStateAndStartWatchingLocked();
@@ -405,8 +406,8 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
       // Only update connectivity state in case 1.
       if (subchannel_list() == p->subchannel_list_.get()) {
         p->channel_control_helper()->UpdateState(
-            GRPC_CHANNEL_CONNECTING,
-            MakeUnique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+            GRPC_CHANNEL_CONNECTING, absl::make_unique<QueuePicker>(p->Ref(
+                                         DEBUG_LOCATION, "QueuePicker")));
       }
       break;
     }
@@ -445,7 +446,7 @@ void PickFirst::PickFirstSubchannelData::ProcessUnselectedReadyLocked() {
   }
   p->selected_ = this;
   p->channel_control_helper()->UpdateState(
-      GRPC_CHANNEL_READY, MakeUnique<Picker>(subchannel()->Ref()));
+      GRPC_CHANNEL_READY, absl::make_unique<Picker>(subchannel()->Ref()));
   for (size_t i = 0; i < subchannel_list()->num_subchannels(); ++i) {
     if (i != Index()) {
       subchannel_list()->subchannel(i)->ShutdownLocked();
@@ -471,7 +472,7 @@ void PickFirst::PickFirstSubchannelData::
   }
 }
 
-class ParsedPickFirstConfig : public LoadBalancingPolicy::Config {
+class PickFirstConfig : public LoadBalancingPolicy::Config {
  public:
   const char* name() const override { return kPickFirst; }
 };
@@ -490,12 +491,8 @@ class PickFirstFactory : public LoadBalancingPolicyFactory {
   const char* name() const override { return kPickFirst; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** /*error*/) const override {
-    if (json != nullptr) {
-      GPR_DEBUG_ASSERT(strcmp(json->key, name()) == 0);
-    }
-    return RefCountedPtr<LoadBalancingPolicy::Config>(
-        new ParsedPickFirstConfig());
+      const Json& json, grpc_error** /*error*/) const override {
+    return MakeRefCounted<PickFirstConfig>();
   }
 };
 
@@ -506,7 +503,7 @@ class PickFirstFactory : public LoadBalancingPolicyFactory {
 void grpc_lb_policy_pick_first_init() {
   grpc_core::LoadBalancingPolicyRegistry::Builder::
       RegisterLoadBalancingPolicyFactory(
-          grpc_core::MakeUnique<grpc_core::PickFirstFactory>());
+          absl::make_unique<grpc_core::PickFirstFactory>());
 }
 
 void grpc_lb_policy_pick_first_shutdown() {}