grpc 1.28.0.pre2 → 1.31.0.pre1

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

@@ -80,10 +80,6 @@ class FakeResolverResponseGenerator
   // Set the corresponding FakeResolver to this generator.
   void SetFakeResolver(RefCountedPtr<FakeResolver> resolver);
 
-  static void SetResponseLocked(void* arg, grpc_error* error);
-  static void SetReresolutionResponseLocked(void* arg, grpc_error* error);
-  static void SetFailureLocked(void* arg, grpc_error* error);
-
   // Mutex protecting the members below.
   Mutex mu_;
   RefCountedPtr<FakeResolver> resolver_;

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

@@ -31,9 +31,9 @@
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -57,7 +57,7 @@ class SockaddrResolver : public Resolver {
 
 SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
                                    ResolverArgs args)
-    : Resolver(args.combiner, std::move(args.result_handler)),
+    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
       addresses_(std::move(addresses)),
       channel_args_(grpc_channel_args_copy(args.args)) {}
 

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -18,12 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/xds/xds_client.h"
-#include "src/core/lib/gprpp/string_view.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/transport/timeout_encoding.h"
 
 namespace grpc_core {
 
+TraceFlag grpc_xds_resolver_trace(false, "xds_resolver");
+
 namespace {
 
 //
@@ -33,19 +37,35 @@ namespace {
 class XdsResolver : public Resolver {
  public:
   explicit XdsResolver(ResolverArgs args)
-      : Resolver(args.combiner, std::move(args.result_handler)),
+      : Resolver(std::move(args.work_serializer),
+                 std::move(args.result_handler)),
         args_(grpc_channel_args_copy(args.args)),
-        interested_parties_(args.pollset_set) {
+        interested_parties_(args.pollset_set),
+        config_selector_(MakeRefCounted<XdsConfigSelector>()) {
     char* path = args.uri->path;
     if (path[0] == '/') ++path;
-    server_name_.reset(gpr_strdup(path));
+    server_name_ = path;
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] created for server name %s", this,
+              server_name_.c_str());
+    }
   }
 
-  ~XdsResolver() override { grpc_channel_args_destroy(args_); }
+  ~XdsResolver() override {
+    grpc_channel_args_destroy(args_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] destroyed", this);
+    }
+  }
 
   void StartLocked() override;
 
-  void ShutdownLocked() override { xds_client_.reset(); }
+  void ShutdownLocked() override {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] shutting down", this);
+    }
+    xds_client_.reset();
+  }
 
  private:
   class ServiceConfigWatcher : public XdsClient::ServiceConfigWatcherInterface {
@@ -55,30 +75,48 @@ class XdsResolver : public Resolver {
     void OnServiceConfigChanged(
         RefCountedPtr<ServiceConfig> service_config) override;
     void OnError(grpc_error* error) override;
+    void OnResourceDoesNotExist() override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
   };
 
-  grpc_core::UniquePtr<char> server_name_;
+  class XdsConfigSelector : public ConfigSelector {
+   public:
+    CallConfig GetCallConfig(GetCallConfigArgs args) override {
+      return CallConfig();
+    }
+  };
+
+  std::string server_name_;
   const grpc_channel_args* args_;
   grpc_pollset_set* interested_parties_;
   OrphanablePtr<XdsClient> xds_client_;
+  RefCountedPtr<XdsConfigSelector> config_selector_;
 };
 
 void XdsResolver::ServiceConfigWatcher::OnServiceConfigChanged(
     RefCountedPtr<ServiceConfig> service_config) {
   if (resolver_->xds_client_ == nullptr) return;
-  grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] received updated service config: %s",
+            resolver_.get(), service_config->json_string().c_str());
+  }
+  grpc_arg new_args[] = {
+      resolver_->xds_client_->MakeChannelArg(),
+      resolver_->config_selector_->MakeChannelArg(),
+  };
   Result result;
-  result.args =
-      grpc_channel_args_copy_and_add(resolver_->args_, &xds_client_arg, 1);
+  result.args = grpc_channel_args_copy_and_add(resolver_->args_, new_args,
+                                               GPR_ARRAY_SIZE(new_args));
   result.service_config = std::move(service_config);
   resolver_->result_handler()->ReturnResult(std::move(result));
 }
 
 void XdsResolver::ServiceConfigWatcher::OnError(grpc_error* error) {
   if (resolver_->xds_client_ == nullptr) return;
+  gpr_log(GPR_ERROR, "[xds_resolver %p] received error: %s", resolver_.get(),
+          grpc_error_string(error));
   grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
   Result result;
   result.args =
@@ -87,10 +125,24 @@ void XdsResolver::ServiceConfigWatcher::OnError(grpc_error* error) {
   resolver_->result_handler()->ReturnResult(std::move(result));
 }
 
+void XdsResolver::ServiceConfigWatcher::OnResourceDoesNotExist() {
+  if (resolver_->xds_client_ == nullptr) return;
+  gpr_log(GPR_ERROR,
+          "[xds_resolver %p] LDS/RDS resource does not exist -- returning "
+          "empty service config",
+          resolver_.get());
+  Result result;
+  result.service_config =
+      ServiceConfig::Create("{}", &result.service_config_error);
+  GPR_ASSERT(result.service_config != nullptr);
+  result.args = grpc_channel_args_copy(resolver_->args_);
+  resolver_->result_handler()->ReturnResult(std::move(result));
+}
+
 void XdsResolver::StartLocked() {
   grpc_error* error = GRPC_ERROR_NONE;
   xds_client_ = MakeOrphanable<XdsClient>(
-      combiner(), interested_parties_, StringView(server_name_.get()),
+      work_serializer(), interested_parties_, server_name_,
       absl::make_unique<ServiceConfigWatcher>(Ref()), *args_, &error);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR,
@@ -120,7 +172,7 @@ class XdsResolverFactory : public ResolverFactory {
     return MakeOrphanable<XdsResolver>(std::move(args));
   }
 
-  const char* scheme() const override { return "xds-experimental"; }
+  const char* scheme() const override { return "xds"; }
 };
 
 }  // namespace

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

@@ -38,8 +38,8 @@ struct ResolverArgs {
   const grpc_channel_args* args = nullptr;
   /// Used to drive I/O in the name resolution process.
   grpc_pollset_set* pollset_set = nullptr;
-  /// The combiner under which all resolver calls will be run.
-  Combiner* combiner = nullptr;
+  /// The work_serializer under which all resolver calls will be run.
+  std::shared_ptr<WorkSerializer> work_serializer;
   /// The result handler to be used by the resolver.
   std::unique_ptr<Resolver::ResultHandler> result_handler;
 };

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

@@ -22,6 +22,9 @@
 
 #include <string.h>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -63,22 +66,22 @@ class RegistryState {
   // If \a default_prefix_ needs to be prepended, sets \a canonical_target
   // to the canonical target string.
   ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
-                                       char** canonical_target) const {
+                                       std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
     *uri = grpc_uri_parse(target, 1);
     ResolverFactory* factory =
         *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
     if (factory == nullptr) {
       grpc_uri_destroy(*uri);
-      gpr_asprintf(canonical_target, "%s%s", default_prefix_.get(), target);
-      *uri = grpc_uri_parse(*canonical_target, 1);
+      *canonical_target = absl::StrCat(default_prefix_.get(), target);
+      *uri = grpc_uri_parse(canonical_target->c_str(), 1);
       factory =
           *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
       if (factory == nullptr) {
         grpc_uri_destroy(grpc_uri_parse(target, 0));
-        grpc_uri_destroy(grpc_uri_parse(*canonical_target, 0));
+        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), 0));
         gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
-                *canonical_target);
+                canonical_target->c_str());
       }
     }
     return factory;
@@ -90,7 +93,7 @@ class RegistryState {
   // more factories are needed and the additional allocations are
   // hurting performance (which is unlikely, since these allocations
   // only occur at gRPC initialization time).
-  InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
+  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
   grpc_core::UniquePtr<char> default_prefix_;
 };
 
@@ -134,35 +137,34 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
 
 bool ResolverRegistry::IsValidTarget(const char* target) {
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   bool result = factory == nullptr ? false : factory->IsValidUri(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return result;
 }
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set, Combiner* combiner,
+    grpc_pollset_set* pollset_set,
+    std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   ResolverArgs resolver_args;
   resolver_args.uri = uri;
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
-  resolver_args.combiner = combiner;
+  resolver_args.work_serializer = std::move(work_serializer);
   resolver_args.result_handler = std::move(result_handler);
   OrphanablePtr<Resolver> resolver =
       factory == nullptr ? nullptr
                          : factory->CreateResolver(std::move(resolver_args));
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return resolver;
 }
 
@@ -170,13 +172,12 @@ grpc_core::UniquePtr ResolverRegistry::GetDefaultAuthority(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_core::UniquePtr<char> authority =
       factory == nullptr ? nullptr : factory->GetDefaultAuthority(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return authority;
 }
 
@@ -184,11 +185,12 @@ grpc_core::UniquePtr ResolverRegistry::AddDefaultPrefixIfNeeded(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return grpc_core::UniquePtr<char>(
-      canonical_target == nullptr ? gpr_strdup(target) : canonical_target);
+  return grpc_core::UniquePtr<char>(canonical_target.empty()
+                                        ? gpr_strdup(target)
+                                        : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/resolver_factory.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -61,15 +60,16 @@ class ResolverRegistry {
   /// prepends default_prefix to target and tries again.
   /// If a resolver factory is found, uses it to instantiate a resolver and
   /// returns it; otherwise, returns nullptr.
-  /// \a args, \a pollset_set, and \a combiner are passed to the factory's
-  /// \a CreateResolver() method.
-  /// \a args are the channel args to be included in resolver results.
-  /// \a pollset_set is used to drive I/O in the name resolution process.
-  /// \a combiner is the combiner under which all resolver calls will be run.
-  /// \a result_handler is used to return results from the resolver.
+  /// \a args, \a pollset_set, and \a work_serializer are passed to the
+  /// factory's \a CreateResolver() method. \a args are the channel args to be
+  /// included in resolver results. \a pollset_set is used to drive I/O in the
+  /// name resolution process. \a work_serializer is the work_serializer under
+  /// which all resolver calls will be run. \a result_handler is used to return
+  /// results from the resolver.
   static OrphanablePtr<Resolver> CreateResolver(
       const char* target, const grpc_channel_args* args,
-      grpc_pollset_set* pollset_set, Combiner* combiner,
+      grpc_pollset_set* pollset_set,
+      std::shared_ptr<WorkSerializer> work_serializer,
       std::unique_ptr<Resolver::ResultHandler> result_handler);
 
   /// Returns the default authority to pass from a client for \a target.

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

@@ -24,6 +24,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -35,7 +38,6 @@
 #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/gprpp/optional.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
@@ -53,8 +55,9 @@ size_t ClientChannelServiceConfigParser::ParserIndex() {
 }
 
 void ClientChannelServiceConfigParser::Register() {
-  g_client_channel_service_config_parser_index = ServiceConfig::RegisterParser(
-      absl::make_unique<ClientChannelServiceConfigParser>());
+  g_client_channel_service_config_parser_index =
+      ServiceConfigParser::RegisterParser(
+          absl::make_unique<ClientChannelServiceConfigParser>());
 }
 
 namespace {
@@ -311,14 +314,15 @@ const char* ParseHealthCheckConfig(const Json& field, grpc_error** error) {
 
 }  // namespace
 
-std::unique_ptr<ServiceConfig::ParsedConfig>
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
 ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
                                                     grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   std::vector<grpc_error*> error_list;
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
-  grpc_core::UniquePtr<char> lb_policy_name;
-  Optional<ClientChannelGlobalParsedConfig::RetryThrottling> retry_throttling;
+  std::string lb_policy_name;
+  absl::optional<ClientChannelGlobalParsedConfig::RetryThrottling>
+      retry_throttling;
   const char* health_check_service_name = nullptr;
   // Parse LB config.
   auto it = json.object_value().find("loadBalancingConfig");
@@ -340,26 +344,21 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "field:loadBalancingPolicy error:type should be string"));
     } else {
-      lb_policy_name.reset(gpr_strdup(it->second.string_value().c_str()));
-      char* lb_policy = lb_policy_name.get();
-      if (lb_policy != nullptr) {
-        for (size_t i = 0; i < strlen(lb_policy); ++i) {
-          lb_policy[i] = tolower(lb_policy[i]);
-        }
+      lb_policy_name = it->second.string_value();
+      for (size_t i = 0; i < lb_policy_name.size(); ++i) {
+        lb_policy_name[i] = tolower(lb_policy_name[i]);
       }
       bool requires_config = false;
       if (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-              lb_policy, &requires_config)) {
+              lb_policy_name.c_str(), &requires_config)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:loadBalancingPolicy error:Unknown lb policy"));
       } else if (requires_config) {
-        char* error_msg;
-        gpr_asprintf(&error_msg,
-                     "field:loadBalancingPolicy error:%s requires a config. "
-                     "Please use loadBalancingConfig instead.",
-                     lb_policy);
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg));
-        gpr_free(error_msg);
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrCat("field:loadBalancingPolicy error:", lb_policy_name,
+                         " requires a config. Please use loadBalancingConfig "
+                         "instead.")
+                .c_str()));
       }
     }
   }
@@ -394,12 +393,12 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
   return nullptr;
 }
 
-std::unique_ptr<ServiceConfig::ParsedConfig>
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
 ClientChannelServiceConfigParser::ParsePerMethodParams(const Json& json,
                                                        grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   std::vector<grpc_error*> error_list;
-  Optional<bool> wait_for_ready;
+  absl::optional<bool> wait_for_ready;
   grpc_millis timeout = 0;
   std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> retry_policy;
   // Parse waitForReady.

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

@@ -21,13 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
@@ -37,7 +38,8 @@
 namespace grpc_core {
 namespace internal {
 
-class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
+class ClientChannelGlobalParsedConfig
+    : public ServiceConfigParser::ParsedConfig {
  public:
   struct RetryThrottling {
     intptr_t max_milli_tokens = 0;
@@ -46,15 +48,15 @@ class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
 
   ClientChannelGlobalParsedConfig(
       RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config,
-      grpc_core::UniquePtr<char> parsed_deprecated_lb_policy,
-      const Optional<RetryThrottling>& retry_throttling,
+      std::string parsed_deprecated_lb_policy,
+      const absl::optional<RetryThrottling>& retry_throttling,
       const char* health_check_service_name)
       : parsed_lb_config_(std::move(parsed_lb_config)),
         parsed_deprecated_lb_policy_(std::move(parsed_deprecated_lb_policy)),
         retry_throttling_(retry_throttling),
         health_check_service_name_(health_check_service_name) {}
 
-  Optional<RetryThrottling> retry_throttling() const {
+  absl::optional<RetryThrottling> retry_throttling() const {
     return retry_throttling_;
   }
 
@@ -62,8 +64,8 @@ class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
     return parsed_lb_config_;
   }
 
-  const char* parsed_deprecated_lb_policy() const {
-    return parsed_deprecated_lb_policy_.get();
+  const std::string& parsed_deprecated_lb_policy() const {
+    return parsed_deprecated_lb_policy_;
   }
 
   const char* health_check_service_name() const {
@@ -72,12 +74,13 @@ class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
 
  private:
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config_;
-  grpc_core::UniquePtr<char> parsed_deprecated_lb_policy_;
-  Optional<RetryThrottling> retry_throttling_;
+  std::string parsed_deprecated_lb_policy_;
+  absl::optional<RetryThrottling> retry_throttling_;
   const char* health_check_service_name_;
 };
 
-class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
+class ClientChannelMethodParsedConfig
+    : public ServiceConfigParser::ParsedConfig {
  public:
   struct RetryPolicy {
     int max_attempts = 0;
@@ -88,7 +91,7 @@ class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
   };
 
   ClientChannelMethodParsedConfig(grpc_millis timeout,
-                                  const Optional<bool>& wait_for_ready,
+                                  const absl::optional<bool>& wait_for_ready,
                                   std::unique_ptr<RetryPolicy> retry_policy)
       : timeout_(timeout),
         wait_for_ready_(wait_for_ready),
@@ -96,22 +99,22 @@ class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
 
   grpc_millis timeout() const { return timeout_; }
 
-  Optional<bool> wait_for_ready() const { return wait_for_ready_; }
+  absl::optional<bool> wait_for_ready() const { return wait_for_ready_; }
 
   const RetryPolicy* retry_policy() const { return retry_policy_.get(); }
 
  private:
   grpc_millis timeout_ = 0;
-  Optional<bool> wait_for_ready_;
+  absl::optional<bool> wait_for_ready_;
   std::unique_ptr<RetryPolicy> retry_policy_;
 };
 
-class ClientChannelServiceConfigParser : public ServiceConfig::Parser {
+class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
  public:
-  std::unique_ptr<ServiceConfig::ParsedConfig> ParseGlobalParams(
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
       const Json& json, grpc_error** error) override;
 
-  std::unique_ptr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
       const Json& json, grpc_error** error) override;
 
   static size_t ParserIndex();