grpc 1.17.1 → 1.18.0.pre1

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

@@ -29,16 +29,17 @@ struct grpc_ares_request {
 static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    grpc_lb_addresses** addrs, bool check_grpclb, char** service_config_json,
-    int query_timeout_ms, grpc_combiner* combiner) {
+    grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
+    bool check_grpclb, char** service_config_json, int query_timeout_ms,
+    grpc_combiner* combiner) {
   return NULL;
 }
 
 grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    grpc_lb_addresses** addrs, bool check_grpclb, char** service_config_json,
-    int query_timeout_ms,
+    grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs,
+    bool check_grpclb, char** service_config_json, int query_timeout_ms,
     grpc_combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
 
 static void grpc_cancel_ares_request_locked_impl(grpc_ares_request* r) {}

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

@@ -27,7 +27,8 @@
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 
 bool grpc_ares_maybe_resolve_localhost_manually_locked(
-    const char* name, const char* default_port, grpc_lb_addresses** addrs) {
+    const char* name, const char* default_port,
+    grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs) {
   return false;
 }
 

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

@@ -23,9 +23,9 @@
 
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
@@ -33,8 +33,9 @@
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 
 static bool inner_maybe_resolve_localhost_manually_locked(
-    const char* name, const char* default_port, grpc_lb_addresses** addrs,
-    char** host, char** port) {
+    const char* name, const char* default_port,
+    grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs, char** host,
+    char** port) {
   gpr_split_host_port(name, host, port);
   if (*host == nullptr) {
     gpr_log(GPR_ERROR,
@@ -55,7 +56,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(*host, "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = grpc_lb_addresses_create(2, nullptr);
+    *addrs = grpc_core::MakeUnique<grpc_core::ServerAddressList>();
     uint16_t numeric_port = grpc_strhtons(*port);
     // Append the ipv6 loopback address.
     struct sockaddr_in6 ipv6_loopback_addr;
@@ -63,10 +64,8 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ((char*)&ipv6_loopback_addr.sin6_addr)[15] = 1;
     ipv6_loopback_addr.sin6_family = AF_INET6;
     ipv6_loopback_addr.sin6_port = numeric_port;
-    grpc_lb_addresses_set_address(
-        *addrs, 0, &ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
-        false /* is_balancer */, nullptr /* balancer_name */,
-        nullptr /* user_data */);
+    (*addrs)->emplace_back(&ipv6_loopback_addr, sizeof(ipv6_loopback_addr),
+                           nullptr /* args */);
     // Append the ipv4 loopback address.
     struct sockaddr_in ipv4_loopback_addr;
     memset(&ipv4_loopback_addr, 0, sizeof(ipv4_loopback_addr));
@@ -74,19 +73,18 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     ((char*)&ipv4_loopback_addr.sin_addr)[3] = 0x01;
     ipv4_loopback_addr.sin_family = AF_INET;
     ipv4_loopback_addr.sin_port = numeric_port;
-    grpc_lb_addresses_set_address(
-        *addrs, 1, &ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
-        false /* is_balancer */, nullptr /* balancer_name */,
-        nullptr /* user_data */);
+    (*addrs)->emplace_back(&ipv4_loopback_addr, sizeof(ipv4_loopback_addr),
+                           nullptr /* args */);
     // Let the address sorter figure out which one should be tried first.
-    grpc_cares_wrapper_address_sorting_sort(*addrs);
+    grpc_cares_wrapper_address_sorting_sort(addrs->get());
     return true;
   }
   return false;
 }
 
 bool grpc_ares_maybe_resolve_localhost_manually_locked(
-    const char* name, const char* default_port, grpc_lb_addresses** addrs) {
+    const char* name, const char* default_port,
+    grpc_core::UniquePtr<grpc_core::ServerAddressList>* addrs) {
   char* host = nullptr;
   char* port = nullptr;
   bool out = inner_maybe_resolve_localhost_manually_locked(name, default_port,

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -26,8 +26,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/env.h"
@@ -198,18 +198,14 @@ void NativeDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
       grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
                          grpc_slice_from_copied_string(r->name_to_resolve_));
   if (r->addresses_ != nullptr) {
-    grpc_lb_addresses* addresses = grpc_lb_addresses_create(
-        r->addresses_->naddrs, nullptr /* user_data_vtable */);
+    ServerAddressList addresses;
     for (size_t i = 0; i < r->addresses_->naddrs; ++i) {
-      grpc_lb_addresses_set_address(
-          addresses, i, &r->addresses_->addrs[i].addr,
-          r->addresses_->addrs[i].len, false /* is_balancer */,
-          nullptr /* balancer_name */, nullptr /* user_data */);
+      addresses.emplace_back(&r->addresses_->addrs[i].addr,
+                             r->addresses_->addrs[i].len, nullptr /* args */);
     }
-    grpc_arg new_arg = grpc_lb_addresses_create_channel_arg(addresses);
+    grpc_arg new_arg = CreateServerAddressListChannelArg(&addresses);
     result = grpc_channel_args_copy_and_add(r->channel_args_, &new_arg, 1);
     grpc_resolved_addresses_destroy(r->addresses_);
-    grpc_lb_addresses_destroy(addresses);
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     r->backoff_.Reset();

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

@@ -28,12 +28,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/resolve_address.h"

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

@@ -19,10 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/lib/iomgr/error.h"
 
 #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \
   "grpc.fake_resolver.response_generator"

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -26,9 +26,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/host_port.h"
 #include "src/core/lib/gpr/string.h"
@@ -45,7 +45,8 @@ namespace {
 class SockaddrResolver : public Resolver {
  public:
   /// Takes ownership of \a addresses.
-  SockaddrResolver(const ResolverArgs& args, grpc_lb_addresses* addresses);
+  SockaddrResolver(const ResolverArgs& args,
+                   UniquePtr<ServerAddressList> addresses);
 
   void NextLocked(grpc_channel_args** result,
                   grpc_closure* on_complete) override;
@@ -58,7 +59,7 @@ class SockaddrResolver : public Resolver {
   void MaybeFinishNextLocked();
 
   /// the addresses that we've "resolved"
-  grpc_lb_addresses* addresses_ = nullptr;
+  UniquePtr<ServerAddressList> addresses_;
   /// channel args
   grpc_channel_args* channel_args_ = nullptr;
   /// have we published?
@@ -70,13 +71,12 @@ class SockaddrResolver : public Resolver {
 };
 
 SockaddrResolver::SockaddrResolver(const ResolverArgs& args,
-                                   grpc_lb_addresses* addresses)
+                                   UniquePtr<ServerAddressList> addresses)
     : Resolver(args.combiner),
-      addresses_(addresses),
+      addresses_(std::move(addresses)),
       channel_args_(grpc_channel_args_copy(args.args)) {}
 
 SockaddrResolver::~SockaddrResolver() {
-  grpc_lb_addresses_destroy(addresses_);
   grpc_channel_args_destroy(channel_args_);
 }
 
@@ -100,7 +100,7 @@ void SockaddrResolver::ShutdownLocked() {
 void SockaddrResolver::MaybeFinishNextLocked() {
   if (next_completion_ != nullptr && !published_) {
     published_ = true;
-    grpc_arg arg = grpc_lb_addresses_create_channel_arg(addresses_);
+    grpc_arg arg = CreateServerAddressListChannelArg(addresses_.get());
     *target_result_ = grpc_channel_args_copy_and_add(channel_args_, &arg, 1);
     GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE);
     next_completion_ = nullptr;
@@ -127,27 +127,27 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
   grpc_slice_buffer path_parts;
   grpc_slice_buffer_init(&path_parts);
   grpc_slice_split(path_slice, ",", &path_parts);
-  grpc_lb_addresses* addresses = grpc_lb_addresses_create(
-      path_parts.count, nullptr /* user_data_vtable */);
+  auto addresses = MakeUnique<ServerAddressList>();
   bool errors_found = false;
-  for (size_t i = 0; i < addresses->num_addresses; i++) {
+  for (size_t i = 0; i < path_parts.count; i++) {
     grpc_uri ith_uri = *args.uri;
-    char* part_str = grpc_slice_to_c_string(path_parts.slices[i]);
-    ith_uri.path = part_str;
-    if (!parse(&ith_uri, &addresses->addresses[i].address)) {
+    UniquePtr<char> part_str(grpc_slice_to_c_string(path_parts.slices[i]));
+    ith_uri.path = part_str.get();
+    grpc_resolved_address addr;
+    if (!parse(&ith_uri, &addr)) {
       errors_found = true; /* GPR_TRUE */
+      break;
     }
-    gpr_free(part_str);
-    if (errors_found) break;
+    addresses->emplace_back(addr, nullptr /* args */);
   }
   grpc_slice_buffer_destroy_internal(&path_parts);
   grpc_slice_unref_internal(path_slice);
   if (errors_found) {
-    grpc_lb_addresses_destroy(addresses);
     return OrphanablePtr<Resolver>(nullptr);
   }
   // Instantiate resolver.
-  return OrphanablePtr<Resolver>(New<SockaddrResolver>(args, addresses));
+  return OrphanablePtr<Resolver>(
+      New<SockaddrResolver>(args, std::move(addresses)));
 }
 
 class IPv4ResolverFactory : public ResolverFactory {

data/src/core/ext/filters/client_channel/resolver_result_parsing.cc

@@ -30,9 +30,11 @@
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
 #define MAX_MAX_RETRY_ATTEMPTS 5
@@ -40,38 +42,17 @@
 namespace grpc_core {
 namespace internal {
 
-namespace {
-
-// Converts string format from JSON to proto.
-grpc_core::UniquePtr<char> ConvertCamelToSnake(const char* camel) {
-  const size_t size = strlen(camel);
-  char* snake = static_cast<char*>(gpr_malloc(size * 2));
-  size_t j = 0;
-  for (size_t i = 0; i < size; ++i) {
-    if (isupper(camel[i])) {
-      snake[j++] = '_';
-      snake[j++] = tolower(camel[i]);
-    } else {
-      snake[j++] = camel[i];
-    }
-  }
-  snake[j] = '\0';
-  return grpc_core::UniquePtr<char>(snake);
-}
-
-}  // namespace
-
 ProcessedResolverResult::ProcessedResolverResult(
-    const grpc_channel_args* resolver_result, bool parse_retry) {
+    const grpc_channel_args& resolver_result, bool parse_retry) {
   ProcessServiceConfig(resolver_result, parse_retry);
   // If no LB config was found above, just find the LB policy name then.
-  if (lb_policy_config_ == nullptr) ProcessLbPolicyName(resolver_result);
+  if (lb_policy_name_ == nullptr) ProcessLbPolicyName(resolver_result);
 }
 
 void ProcessedResolverResult::ProcessServiceConfig(
-    const grpc_channel_args* resolver_result, bool parse_retry) {
+    const grpc_channel_args& resolver_result, bool parse_retry) {
   const grpc_arg* channel_arg =
-      grpc_channel_args_find(resolver_result, GRPC_ARG_SERVICE_CONFIG);
+      grpc_channel_args_find(&resolver_result, GRPC_ARG_SERVICE_CONFIG);
   const char* service_config_json = grpc_channel_arg_get_string(channel_arg);
   if (service_config_json != nullptr) {
     service_config_json_.reset(gpr_strdup(service_config_json));
@@ -79,7 +60,7 @@ void ProcessedResolverResult::ProcessServiceConfig(
     if (service_config_ != nullptr) {
       if (parse_retry) {
         channel_arg =
-            grpc_channel_args_find(resolver_result, GRPC_ARG_SERVER_URI);
+            grpc_channel_args_find(&resolver_result, GRPC_ARG_SERVER_URI);
         const char* server_uri = grpc_channel_arg_get_string(channel_arg);
         GPR_ASSERT(server_uri != nullptr);
         grpc_uri* uri = grpc_uri_parse(server_uri, true);
@@ -97,42 +78,56 @@ void ProcessedResolverResult::ProcessServiceConfig(
 }
 
 void ProcessedResolverResult::ProcessLbPolicyName(
-    const grpc_channel_args* resolver_result) {
-  const char* lb_policy_name = nullptr;
+    const grpc_channel_args& resolver_result) {
   // Prefer the LB policy name found in the service config. Note that this is
   // checking the deprecated loadBalancingPolicy field, rather than the new
   // loadBalancingConfig field.
   if (service_config_ != nullptr) {
-    lb_policy_name = service_config_->GetLoadBalancingPolicyName();
+    lb_policy_name_.reset(
+        gpr_strdup(service_config_->GetLoadBalancingPolicyName()));
+    // Convert to lower-case.
+    if (lb_policy_name_ != nullptr) {
+      char* lb_policy_name = lb_policy_name_.get();
+      for (size_t i = 0; i < strlen(lb_policy_name); ++i) {
+        lb_policy_name[i] = tolower(lb_policy_name[i]);
+      }
+    }
   }
   // Otherwise, find the LB policy name set by the client API.
-  if (lb_policy_name == nullptr) {
+  if (lb_policy_name_ == nullptr) {
     const grpc_arg* channel_arg =
-        grpc_channel_args_find(resolver_result, GRPC_ARG_LB_POLICY_NAME);
-    lb_policy_name = grpc_channel_arg_get_string(channel_arg);
+        grpc_channel_args_find(&resolver_result, GRPC_ARG_LB_POLICY_NAME);
+    lb_policy_name_.reset(gpr_strdup(grpc_channel_arg_get_string(channel_arg)));
   }
   // Special case: If at least one balancer address is present, we use
   // the grpclb policy, regardless of what the resolver has returned.
-  const grpc_arg* channel_arg =
-      grpc_channel_args_find(resolver_result, GRPC_ARG_LB_ADDRESSES);
-  if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_POINTER) {
-    grpc_lb_addresses* addresses =
-        static_cast<grpc_lb_addresses*>(channel_arg->value.pointer.p);
-    if (grpc_lb_addresses_contains_balancer_address(*addresses)) {
-      if (lb_policy_name != nullptr &&
-          gpr_stricmp(lb_policy_name, "grpclb") != 0) {
+  const ServerAddressList* addresses =
+      FindServerAddressListChannelArg(&resolver_result);
+  if (addresses != nullptr) {
+    bool found_balancer_address = false;
+    for (size_t i = 0; i < addresses->size(); ++i) {
+      const ServerAddress& address = (*addresses)[i];
+      if (address.IsBalancer()) {
+        found_balancer_address = true;
+        break;
+      }
+    }
+    if (found_balancer_address) {
+      if (lb_policy_name_ != nullptr &&
+          strcmp(lb_policy_name_.get(), "grpclb") != 0) {
         gpr_log(GPR_INFO,
                 "resolver requested LB policy %s but provided at least one "
                 "balancer address -- forcing use of grpclb LB policy",
-                lb_policy_name);
+                lb_policy_name_.get());
       }
-      lb_policy_name = "grpclb";
+      lb_policy_name_.reset(gpr_strdup("grpclb"));
     }
   }
   // Use pick_first if nothing was specified and we didn't select grpclb
   // above.
-  if (lb_policy_name == nullptr) lb_policy_name = "pick_first";
-  lb_policy_name_.reset(gpr_strdup(lb_policy_name));
+  if (lb_policy_name_ == nullptr) {
+    lb_policy_name_.reset(gpr_strdup("pick_first"));
+  }
 }
 
 void ProcessedResolverResult::ParseServiceConfig(
@@ -175,15 +170,13 @@ void ProcessedResolverResult::ParseLbConfigFromServiceConfig(
       if (policy_content != nullptr) return;  // Violate "oneof" type.
       policy_content = field;
     }
-    grpc_core::UniquePtr<char> lb_policy_name =
-        ConvertCamelToSnake(policy_content->key);
-    if (!grpc_core::LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-            lb_policy_name.get())) {
-      continue;
+    // If we support this policy, then select it.
+    if (grpc_core::LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
+            policy_content->key)) {
+      lb_policy_name_.reset(gpr_strdup(policy_content->key));
+      lb_policy_config_ = policy_content->child;
+      return;
     }
-    lb_policy_name_ = std::move(lb_policy_name);
-    lb_policy_config_ = policy_content->child;
-    return;
   }
 }
 

data/src/core/ext/filters/client_channel/resolver_result_parsing.h

@@ -36,8 +36,7 @@ namespace internal {
 class ClientChannelMethodParams;
 
 // A table mapping from a method name to its method parameters.
-typedef grpc_core::SliceHashTable<
-    grpc_core::RefCountedPtr<ClientChannelMethodParams>>
+typedef SliceHashTable<RefCountedPtr<ClientChannelMethodParams>>
     ClientChannelMethodParamsTable;
 
 // A container of processed fields from the resolver result. Simplifies the
@@ -47,33 +46,30 @@ class ProcessedResolverResult {
   // Processes the resolver result and populates the relative members
   // for later consumption. Tries to parse retry parameters only if parse_retry
   // is true.
-  ProcessedResolverResult(const grpc_channel_args* resolver_result,
+  ProcessedResolverResult(const grpc_channel_args& resolver_result,
                           bool parse_retry);
 
   // Getters. Any managed object's ownership is transferred.
-  grpc_core::UniquePtr<char> service_config_json() {
+  UniquePtr<char> service_config_json() {
     return std::move(service_config_json_);
   }
-  grpc_core::RefCountedPtr<ServerRetryThrottleData> retry_throttle_data() {
+  RefCountedPtr<ServerRetryThrottleData> retry_throttle_data() {
     return std::move(retry_throttle_data_);
   }
-  grpc_core::RefCountedPtr<ClientChannelMethodParamsTable>
-  method_params_table() {
+  RefCountedPtr<ClientChannelMethodParamsTable> method_params_table() {
     return std::move(method_params_table_);
   }
-  grpc_core::UniquePtr<char> lb_policy_name() {
-    return std::move(lb_policy_name_);
-  }
+  UniquePtr<char> lb_policy_name() { return std::move(lb_policy_name_); }
   grpc_json* lb_policy_config() { return lb_policy_config_; }
 
  private:
   // Finds the service config; extracts LB config and (maybe) retry throttle
   // params from it.
-  void ProcessServiceConfig(const grpc_channel_args* resolver_result,
+  void ProcessServiceConfig(const grpc_channel_args& resolver_result,
                             bool parse_retry);
 
   // Finds the LB policy name (when no LB config was found).
-  void ProcessLbPolicyName(const grpc_channel_args* resolver_result);
+  void ProcessLbPolicyName(const grpc_channel_args& resolver_result);
 
   // Parses the service config. Intended to be used by
   // ServiceConfig::ParseGlobalParams.
@@ -85,16 +81,16 @@ class ProcessedResolverResult {
   void ParseRetryThrottleParamsFromServiceConfig(const grpc_json* field);
 
   // Service config.
-  grpc_core::UniquePtr<char> service_config_json_;
-  grpc_core::UniquePtr<grpc_core::ServiceConfig> service_config_;
+  UniquePtr<char> service_config_json_;
+  UniquePtr<grpc_core::ServiceConfig> service_config_;
   // LB policy.
   grpc_json* lb_policy_config_ = nullptr;
-  grpc_core::UniquePtr<char> lb_policy_name_;
+  UniquePtr<char> lb_policy_name_;
   // Retry throttle data.
   char* server_name_ = nullptr;
-  grpc_core::RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;
   // Method params table.
-  grpc_core::RefCountedPtr<ClientChannelMethodParamsTable> method_params_table_;
+  RefCountedPtr<ClientChannelMethodParamsTable> method_params_table_;
 };
 
 // The parameters of a method.