grpc 1.31.0.pre2 → 1.34.0

data/include/grpc/impl/codegen/README.md

@@ -0,0 +1,22 @@
+# Welcome to `include/grpc/impl/codegen`
+
+## Why is this directory here?
+
+This directory exists so that generated C++ code can include selected files upon
+which it depends without having to depend on the entire gRPC C++ library. This
+directory thus exists to support `include/grpcpp/impl/codegen`. This constraint
+is particularly relevant for users of bazel, particularly if they use the
+multi-lingual `proto_library` target type. Generated code that uses this target
+only depends on the gRPC C++ targets associated with these header files, not the
+entire gRPC C++ codebase since that would make the build time of these types of
+targets excessively large (particularly when they are not even C++ specific).
+
+## What should user code do?
+
+User code should *not* include anything from this directory. Only generated code
+and gRPC library code should include contents from this directory. C++ user code
+should instead include contents from the main `grpcpp` directory or its
+accessible subcomponents like `grpcpp/support`. It is possible that we may
+remove this directory altogether if the motivations for its existence are no
+longer strong enough (e.g., if the gRPC C++ library no longer has a need for an
+`impl/codegen` directory of its own).

data/include/grpc/impl/codegen/grpc_types.h

@@ -202,8 +202,15 @@ typedef struct {
 #define GRPC_ARG_HTTP2_MAX_FRAME_SIZE "grpc.http2.max_frame_size"
 /** Should BDP probing be performed? */
 #define GRPC_ARG_HTTP2_BDP_PROBE "grpc.http2.bdp_probe"
-/** Minimum time between sending successive ping frames without receiving any
-    data/header frame, Int valued, milliseconds. */
+/** (DEPRECATED) Does not have any effect.
+    Earlier, this arg configured the minimum time between successive ping frames
+    without receiving any data/header frame, Int valued, milliseconds. This put
+    unnecessary constraints on the configuration of keepalive pings,
+    requiring users to set this channel arg along with
+    GRPC_ARG_KEEPALIVE_TIME_MS. This arg also limited the activity of the other
+    source of pings in gRPC Core - BDP pings, but BDP pings are only sent when
+    there is receive-side data activity, making this arg unuseful for BDP pings
+    too.  */
 #define GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS \
   "grpc.http2.min_time_between_pings_ms"
 /** Minimum allowed time between a server receiving successive ping frames
@@ -355,11 +362,6 @@ typedef struct {
    over to the next priority. Default value is 10 seconds. */
 #define GRPC_ARG_PRIORITY_FAILOVER_TIMEOUT_MS \
   "grpc.priority_failover_timeout_ms"
-/* Timeout in milliseconds to wait for a resource to be returned from
- * the xds server before assuming that it does not exist.
- * The default is 15 seconds. */
-#define GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS \
-  "grpc.xds_resource_does_not_exist_timeout_ms"
 /** If non-zero, grpc server's cronet compression workaround will be enabled */
 #define GRPC_ARG_WORKAROUND_CRONET_COMPRESSION \
   "grpc.workaround.cronet_compression"

data/include/grpc/impl/codegen/port_platform.h

@@ -31,8 +31,13 @@
  * Defines GPR_ABSEIL_SYNC to use synchronization features from Abseil
  */
 #ifndef GPR_ABSEIL_SYNC
-/* #define GPR_ABSEIL_SYNC 1 */
+#if defined(__APPLE__)
+// This is disabled on Apple platforms because macos/grpc_basictests_c_cpp
+// fails with this. https://github.com/grpc/grpc/issues/23661
+#else
+#define GPR_ABSEIL_SYNC 1
 #endif
+#endif  // GPR_ABSEIL_SYNC
 
 /* Get windows.h included everywhere (we need it) */
 #if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
@@ -95,16 +100,16 @@
 #define GPR_WINDOWS_TMPFILE
 #define GPR_WINDOWS_LOG
 #define GPR_WINDOWS_CRASH_HANDLER 1
+#define GPR_WINDOWS_STAT
 #define GPR_WINDOWS_STRING
 #define GPR_WINDOWS_TIME
 #endif
 #ifdef __GNUC__
 #define GPR_GCC_ATOMIC 1
-#define GPR_GCC_TLS 1
 #else
 #define GPR_WINDOWS_ATOMIC 1
-#define GPR_MSVC_TLS 1
 #endif
+#define GPR_STDCPP_TLS 1
 #elif defined(ANDROID) || defined(__ANDROID__)
 #define GPR_PLATFORM_STRING "android"
 #define GPR_ANDROID 1
@@ -119,9 +124,10 @@
 #endif /* _LP64 */
 #define GPR_CPU_POSIX 1
 #define GPR_GCC_SYNC 1
-#define GPR_GCC_TLS 1
+#define GPR_STDCPP_TLS 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_ANDROID_LOG 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
@@ -144,12 +150,13 @@
 #include <features.h>
 #define GPR_CPU_LINUX 1
 #define GPR_GCC_ATOMIC 1
-#define GPR_GCC_TLS 1
+#define GPR_STDCPP_TLS 1
 #define GPR_LINUX 1
 #define GPR_LINUX_LOG
 #define GPR_SUPPORT_CHANNELS_FROM_FD 1
 #define GPR_LINUX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -197,45 +204,28 @@
 #if TARGET_OS_IPHONE
 #define GPR_PLATFORM_STRING "ios"
 #define GPR_CPU_IPHONE 1
-#define GPR_PTHREAD_TLS 1
 #define GRPC_CFSTREAM 1
 /* the c-ares resolver isn't safe to enable on iOS */
 #define GRPC_ARES 0
 #else /* TARGET_OS_IPHONE */
 #define GPR_PLATFORM_STRING "osx"
-#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
-#if __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7
-#define GPR_CPU_IPHONE 1
-#define GPR_PTHREAD_TLS 1
-#else /* __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7 */
 #define GPR_CPU_POSIX 1
-/* TODO(vjpai): there is a reported issue in bazel build for Mac where __thread
-   in a header is currently not working (bazelbuild/bazel#4341). Remove
-   the following conditional and use GPR_GCC_TLS when that is fixed */
-#ifndef GRPC_BAZEL_BUILD
-#define GPR_GCC_TLS 1
-#else /* GRPC_BAZEL_BUILD */
-#define GPR_PTHREAD_TLS 1
-#endif /* GRPC_BAZEL_BUILD */
-#define GPR_APPLE_PTHREAD_NAME 1
+#define GPR_POSIX_CRASH_HANDLER 1
 #endif
-#else /* __MAC_OS_X_VERSION_MIN_REQUIRED */
-#define GPR_CPU_POSIX 1
-/* TODO(vjpai): Remove the following conditional and use only GPR_GCC_TLS
-   when bazelbuild/bazel#4341 is fixed */
-#ifndef GRPC_BAZEL_BUILD
-#define GPR_GCC_TLS 1
-#else /* GRPC_BAZEL_BUILD */
-#define GPR_PTHREAD_TLS 1
-#endif /* GRPC_BAZEL_BUILD */
+#ifdef __has_feature
+#if __has_feature(cxx_thread_local)
+#define GPR_STDCPP_TLS 1
 #endif
-#define GPR_POSIX_CRASH_HANDLER 1
+#endif
+#ifndef GPR_STDCPP_TLS
+#define GPR_PTHREAD_TLS 1
 #endif
 #define GPR_APPLE 1
 #define GPR_GCC_ATOMIC 1
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -262,6 +252,7 @@
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -286,6 +277,7 @@
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -307,6 +299,7 @@
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -330,6 +323,7 @@
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -359,6 +353,7 @@
 #define GPR_POSIX_LOG 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_STRING 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
@@ -385,6 +380,7 @@
 #define GPR_POSIX_SYNC 1
 #define GPR_POSIX_ENV 1
 #define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
 #define GPR_POSIX_SUBPROCESS 1
 #define GPR_POSIX_SYNC 1
 #define GPR_POSIX_STRING 1
@@ -408,30 +404,6 @@
 #endif
 #endif
 
-/*
- *  There are platforms for which TLS should not be used even though the
- * compiler makes it seem like it's supported (Android NDK < r12b for example).
- * This is primarily because of linker problems and toolchain misconfiguration:
- * TLS isn't supported until NDK r12b per
- * https://developer.android.com/ndk/downloads/revision_history.html
- * TLS also does not work with Android NDK if GCC is being used as the compiler
- * instead of Clang.
- * Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
- * <android/ndk-version.h>. For NDK < r16, users should define these macros,
- * e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11. */
-#if defined(__ANDROID__) && defined(GPR_GCC_TLS)
-#if __has_include(<android/ndk-version.h>)
-#include <android/ndk-version.h>
-#endif /* __has_include(<android/ndk-version.h>) */
-#if (defined(__clang__) && defined(__NDK_MAJOR__) && defined(__NDK_MINOR__) && \
-     ((__NDK_MAJOR__ < 12) ||                                                  \
-      ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))) ||                      \
-    (defined(__GNUC__) && !defined(__clang__))
-#undef GPR_GCC_TLS
-#define GPR_PTHREAD_TLS 1
-#endif
-#endif /*defined(__ANDROID__) && defined(GPR_GCC_TLS) */
-
 #if defined(__has_include)
 #if __has_include(<atomic>)
 #define GRPC_HAS_CXX11_ATOMIC
@@ -520,9 +492,9 @@ typedef unsigned __int64 uint64_t;
 #endif
 
 #if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + \
-        defined(GPR_CUSTOM_TLS) !=                                            \
+        defined(GPR_STDCPP_TLS) + defined(GPR_CUSTOM_TLS) !=                  \
     1
-#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_CUSTOM_TLS
+#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_STDCPP_TLS, GPR_CUSTOM_TLS
 #endif
 
 /* maximum alignment needed for any type on this platform, rounded up to a

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

@@ -106,6 +106,7 @@ static void g_poller_unref() {
                                       grpc_schedule_on_exec_ctx));
     gpr_mu_unlock(p->pollset_mu);
     grpc_timer_cancel(&p->polling_timer);
+    backup_poller_shutdown_unref(p);
   } else {
     gpr_mu_unlock(&g_poller_mu);
   }
@@ -143,8 +144,8 @@ static void g_poller_init_locked() {
     g_poller->shutting_down = false;
     grpc_pollset_init(g_poller->pollset, &g_poller->pollset_mu);
     gpr_ref_init(&g_poller->refs, 0);
-    // one for timer cancellation, one for pollset shutdown
-    gpr_ref_init(&g_poller->shutdown_refs, 2);
+    // one for timer cancellation, one for pollset shutdown, one for g_poller
+    gpr_ref_init(&g_poller->shutdown_refs, 3);
     GRPC_CLOSURE_INIT(&g_poller->run_poller_closure, run_poller, g_poller,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&g_poller->polling_timer,

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

@@ -28,6 +28,8 @@
 
 #include <set>
 
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/alloc.h>
@@ -207,14 +209,15 @@ class ChannelData {
                                 grpc_closure* on_complete,
                                 grpc_closure* watcher_timer_init);
 
-    ~ExternalConnectivityWatcher();
+    ~ExternalConnectivityWatcher() override;
 
     // Removes the watcher from the external_watchers_ map.
     static void RemoveWatcherFromExternalWatchersMap(ChannelData* chand,
                                                      grpc_closure* on_complete,
                                                      bool cancel);
 
-    void Notify(grpc_connectivity_state state) override;
+    void Notify(grpc_connectivity_state state,
+                const absl::Status& /* status */) override;
 
     void Cancel();
 
@@ -238,17 +241,15 @@ class ChannelData {
    public:
     explicit ChannelConfigHelper(ChannelData* chand) : chand_(chand) {}
 
-    ApplyServiceConfigResult ApplyServiceConfig(
+    ChooseServiceConfigResult ChooseServiceConfig(
         const Resolver::Result& result) override;
 
-    void ApplyConfigSelector(
-        bool service_config_changed,
-        RefCountedPtr<ConfigSelector> config_selector) override;
+    void StartUsingServiceConfigForCalls() override;
 
     void ResolverTransientFailure(grpc_error* error) override;
 
    private:
-    static void ProcessLbPolicy(
+    static void ChooseLbPolicy(
         const Resolver::Result& resolver_result,
         const internal::ClientChannelGlobalParsedConfig* parsed_service_config,
         RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config);
@@ -260,12 +261,17 @@ class ChannelData {
   ~ChannelData();
 
   void UpdateStateAndPickerLocked(
-      grpc_connectivity_state state, const char* reason,
+      grpc_connectivity_state state, const absl::Status& status,
+      const char* reason,
       std::unique_ptr<LoadBalancingPolicy::SubchannelPicker> picker);
 
-  void UpdateServiceConfigInDataPlaneLocked(
-      bool service_config_changed,
-      RefCountedPtr<ConfigSelector> config_selector);
+  void UpdateServiceConfigInControlPlaneLocked(
+      RefCountedPtr<ServiceConfig> service_config,
+      RefCountedPtr<ConfigSelector> config_selector,
+      const internal::ClientChannelGlobalParsedConfig* parsed_service_config,
+      const char* lb_policy_name);
+
+  void UpdateServiceConfigInDataPlaneLocked();
 
   void CreateResolvingLoadBalancingPolicyLocked();
 
@@ -316,7 +322,6 @@ class ChannelData {
   grpc_core::UniquePtr<char> health_check_service_name_;
   RefCountedPtr<ServiceConfig> saved_service_config_;
   RefCountedPtr<ConfigSelector> saved_config_selector_;
-  bool received_first_resolver_result_ = false;
   // The number of SubchannelWrapper instances referencing a given Subchannel.
   std::map<Subchannel*, int> subchannel_refcount_map_;
   // The set of SubchannelWrappers that currently exist.
@@ -328,6 +333,7 @@ class ChannelData {
   // applied in the data plane mutex when the picker is updated.
   std::map<RefCountedPtr<SubchannelWrapper>, RefCountedPtr<ConnectedSubchannel>>
       pending_subchannel_updates_;
+  int keepalive_time_ = -1;
 
   //
   // Fields accessed from both data plane mutex and control plane
@@ -888,7 +894,10 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
  public:
   SubchannelWrapper(ChannelData* chand, Subchannel* subchannel,
                     grpc_core::UniquePtr<char> health_check_service_name)
-      : SubchannelInterface(&grpc_client_channel_routing_trace),
+      : SubchannelInterface(
+            GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)
+                ? "SubchannelWrapper"
+                : nullptr),
         chand_(chand),
         subchannel_(subchannel),
         health_check_service_name_(std::move(health_check_service_name)) {
@@ -910,7 +919,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
     chand_->subchannel_wrappers_.insert(this);
   }
 
-  ~SubchannelWrapper() {
+  ~SubchannelWrapper() override {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p: destroying subchannel wrapper %p for subchannel %p",
@@ -973,6 +982,10 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
     return subchannel_->channel_args();
   }
 
+  void ThrottleKeepaliveTime(int new_keepalive_time) {
+    subchannel_->ThrottleKeepaliveTime(new_keepalive_time);
+  }
+
   void UpdateHealthCheckServiceName(
       grpc_core::UniquePtr<char> health_check_service_name) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
@@ -1049,7 +1062,7 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
           parent_(std::move(parent)),
           last_seen_state_(initial_state) {}
 
-    ~WatcherWrapper() {
+    ~WatcherWrapper() override {
       auto* parent = parent_.release();  // ref owned by lambda
       parent->chand_->work_serializer_->Run(
           [parent]() { parent->Unref(DEBUG_LOCATION, "WatcherWrapper"); },
@@ -1099,6 +1112,32 @@ class ChannelData::SubchannelWrapper : public SubchannelInterface {
                 watcher_.get());
       }
       ConnectivityStateChange state_change = PopConnectivityStateChange();
+      absl::optional<absl::Cord> keepalive_throttling =
+          state_change.status.GetPayload(grpc_core::kKeepaliveThrottlingKey);
+      if (keepalive_throttling.has_value()) {
+        int new_keepalive_time = -1;
+        if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
+                             &new_keepalive_time)) {
+          if (new_keepalive_time > parent_->chand_->keepalive_time_) {
+            parent_->chand_->keepalive_time_ = new_keepalive_time;
+            if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+              gpr_log(GPR_INFO, "chand=%p: throttling keepalive time to %d",
+                      parent_->chand_, parent_->chand_->keepalive_time_);
+            }
+            // Propagate the new keepalive time to all subchannels. This is so
+            // that new transports created by any subchannel (and not just the
+            // subchannel that received the GOAWAY), use the new keepalive time.
+            for (auto* subchannel_wrapper :
+                 parent_->chand_->subchannel_wrappers_) {
+              subchannel_wrapper->ThrottleKeepaliveTime(new_keepalive_time);
+            }
+          }
+        } else {
+          gpr_log(GPR_ERROR, "chand=%p: Illegal keepalive throttling value %s",
+                  parent_->chand_,
+                  std::string(keepalive_throttling.value()).c_str());
+        }
+      }
       // Ignore update if the parent WatcherWrapper has been replaced
       // since this callback was scheduled.
       if (watcher_ != nullptr) {
@@ -1212,7 +1251,7 @@ void ChannelData::ExternalConnectivityWatcher::
 }
 
 void ChannelData::ExternalConnectivityWatcher::Notify(
-    grpc_connectivity_state state) {
+    grpc_connectivity_state state, const absl::Status& /* status */) {
   bool done = false;
   if (!done_.CompareExchangeStrong(&done, true, MemoryOrder::RELAXED,
                                    MemoryOrder::RELAXED)) {
@@ -1327,7 +1366,8 @@ class ChannelData::ClientChannelControlHelper
   }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      const grpc_channel_args& args) override {
+      ServerAddress address, const grpc_channel_args& args) override {
+    // Determine health check service name.
     bool inhibit_health_checking = grpc_channel_arg_get_bool(
         grpc_channel_args_find(&args, GRPC_ARG_INHIBIT_HEALTH_CHECKING), false);
     grpc_core::UniquePtr<char> health_check_service_name;
@@ -1335,36 +1375,54 @@ class ChannelData::ClientChannelControlHelper
       health_check_service_name.reset(
           gpr_strdup(chand_->health_check_service_name_.get()));
     }
+    // Remove channel args that should not affect subchannel uniqueness.
     static const char* args_to_remove[] = {
         GRPC_ARG_INHIBIT_HEALTH_CHECKING,
         GRPC_ARG_CHANNELZ_CHANNEL_NODE,
     };
-    grpc_arg arg = SubchannelPoolInterface::CreateChannelArg(
-        chand_->subchannel_pool_.get());
+    // Add channel args needed for the subchannel.
+    absl::InlinedVector<grpc_arg, 3> args_to_add = {
+        Subchannel::CreateSubchannelAddressArg(&address.address()),
+        SubchannelPoolInterface::CreateChannelArg(
+            chand_->subchannel_pool_.get()),
+    };
+    if (address.args() != nullptr) {
+      for (size_t j = 0; j < address.args()->num_args; ++j) {
+        args_to_add.emplace_back(address.args()->args[j]);
+      }
+    }
     grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
-        &args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &arg, 1);
+        &args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove),
+        args_to_add.data(), args_to_add.size());
+    gpr_free(args_to_add[0].value.string);
+    // Create subchannel.
     Subchannel* subchannel =
         chand_->client_channel_factory_->CreateSubchannel(new_args);
     grpc_channel_args_destroy(new_args);
     if (subchannel == nullptr) return nullptr;
+    // Make sure the subchannel has updated keepalive time.
+    subchannel->ThrottleKeepaliveTime(chand_->keepalive_time_);
+    // Create and return wrapper for the subchannel.
     return MakeRefCounted<SubchannelWrapper>(
         chand_, subchannel, std::move(health_check_service_name));
   }
 
   void UpdateState(
-      grpc_connectivity_state state,
+      grpc_connectivity_state state, const absl::Status& status,
       std::unique_ptr<LoadBalancingPolicy::SubchannelPicker> picker) override {
     grpc_error* disconnect_error = chand_->disconnect_error();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
       const char* extra = disconnect_error == GRPC_ERROR_NONE
                               ? ""
                               : " (ignoring -- channel shutting down)";
-      gpr_log(GPR_INFO, "chand=%p: update: state=%s picker=%p%s", chand_,
-              ConnectivityStateName(state), picker.get(), extra);
+      gpr_log(GPR_INFO, "chand=%p: update: state=%s status=(%s) picker=%p%s",
+              chand_, ConnectivityStateName(state), status.ToString().c_str(),
+              picker.get(), extra);
     }
     // Do update only if not shutting down.
     if (disconnect_error == GRPC_ERROR_NONE) {
-      chand_->UpdateStateAndPickerLocked(state, "helper", std::move(picker));
+      chand_->UpdateStateAndPickerLocked(state, status, "helper",
+                                         std::move(picker));
     }
   }
 
@@ -1395,19 +1453,19 @@ class ChannelData::ClientChannelControlHelper
 // ChannelData::ChannelConfigHelper
 //
 
-// Synchronous callback from ResolvingLoadBalancingPolicy to process a
-// resolver result update.
-ChannelData::ChannelConfigHelper::ApplyServiceConfigResult
-ChannelData::ChannelConfigHelper::ApplyServiceConfig(
+ChannelData::ChannelConfigHelper::ChooseServiceConfigResult
+ChannelData::ChannelConfigHelper::ChooseServiceConfig(
     const Resolver::Result& result) {
-  ApplyServiceConfigResult service_config_result;
+  ChooseServiceConfigResult service_config_result;
   RefCountedPtr<ServiceConfig> service_config;
-  // If resolver did not return a service config or returned an invalid service
-  // config, we need a fallback service config.
+  RefCountedPtr<ConfigSelector> config_selector;
   if (result.service_config_error != GRPC_ERROR_NONE) {
-    // If the service config was invalid, then fallback to the saved service
-    // config. If there is no saved config either, use the default service
-    // config.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+      gpr_log(GPR_INFO, "chand=%p: resolver returned service config error: %s",
+              chand_, grpc_error_string(result.service_config_error));
+    }
+    // If the service config was invalid, then fallback to the
+    // previously returned service config.
     if (chand_->saved_service_config_ != nullptr) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
         gpr_log(GPR_INFO,
@@ -1416,99 +1474,60 @@ ChannelData::ChannelConfigHelper::ApplyServiceConfig(
                 chand_);
       }
       service_config = chand_->saved_service_config_;
-    } else if (chand_->default_service_config_ != nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p: resolver returned invalid service config. Using "
-                "default service config provided by client API.",
-                chand_);
-      }
-      service_config = chand_->default_service_config_;
+      config_selector = chand_->saved_config_selector_;
+    } else {
+      // No previously returned config, so put the channel into
+      // TRANSIENT_FAILURE.
+      service_config_result.no_valid_service_config = true;
+      return service_config_result;
     }
   } else if (result.service_config == nullptr) {
-    if (chand_->default_service_config_ != nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
-        gpr_log(GPR_INFO,
-                "chand=%p: resolver returned no service config. Using default "
-                "service config provided by client API.",
-                chand_);
-      }
-      service_config = chand_->default_service_config_;
+    // Resolver did not return any service config.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+      gpr_log(GPR_INFO,
+              "chand=%p: resolver returned no service config. Using default "
+              "service config for channel.",
+              chand_);
     }
+    service_config = chand_->default_service_config_;
   } else {
+    // Use ServiceConfig and ConfigSelector returned by resolver.
     service_config = result.service_config;
+    config_selector = ConfigSelector::GetFromChannelArgs(*result.args);
   }
-  service_config_result.service_config_error =
-      GRPC_ERROR_REF(result.service_config_error);
-  if (service_config == nullptr &&
-      result.service_config_error != GRPC_ERROR_NONE) {
-    service_config_result.no_valid_service_config = true;
-    return service_config_result;
-  }
-  // Process service config.
-  grpc_core::UniquePtr<char> service_config_json;
+  GPR_ASSERT(service_config != nullptr);
+  // Extract global config for client channel.
   const internal::ClientChannelGlobalParsedConfig* parsed_service_config =
-      nullptr;
-  if (service_config != nullptr) {
-    parsed_service_config =
-        static_cast<const internal::ClientChannelGlobalParsedConfig*>(
-            service_config->GetGlobalParsedConfig(
-                internal::ClientChannelServiceConfigParser::ParserIndex()));
-  }
-  // Check if the config has changed.
+      static_cast<const internal::ClientChannelGlobalParsedConfig*>(
+          service_config->GetGlobalParsedConfig(
+              internal::ClientChannelServiceConfigParser::ParserIndex()));
+  // Find LB policy config.
+  ChooseLbPolicy(result, parsed_service_config,
+                 &service_config_result.lb_policy_config);
+  // Check if the ServiceConfig has changed.
+  const bool service_config_changed =
+      chand_->saved_service_config_ == nullptr ||
+      service_config->json_string() !=
+          chand_->saved_service_config_->json_string();
+  // Check if the ConfigSelector has changed.
+  const bool config_selector_changed = !ConfigSelector::Equals(
+      chand_->saved_config_selector_.get(), config_selector.get());
+  // Indicate a change if either the ServiceConfig or ConfigSelector have
+  // changed.
   service_config_result.service_config_changed =
-      ((service_config == nullptr) !=
-       (chand_->saved_service_config_ == nullptr)) ||
-      (service_config != nullptr &&
-       service_config->json_string() !=
-           chand_->saved_service_config_->json_string());
+      service_config_changed || config_selector_changed;
+  // If it has, apply the global parameters now.
   if (service_config_result.service_config_changed) {
-    service_config_json.reset(gpr_strdup(
-        service_config != nullptr ? service_config->json_string().c_str()
-                                  : ""));
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
-      gpr_log(GPR_INFO,
-              "chand=%p: resolver returned updated service config: \"%s\"",
-              chand_, service_config_json.get());
-    }
-    // Save health check service name.
-    if (service_config != nullptr) {
-      chand_->health_check_service_name_.reset(
-          gpr_strdup(parsed_service_config->health_check_service_name()));
-    } else {
-      chand_->health_check_service_name_.reset();
-    }
-    // Update health check service name used by existing subchannel wrappers.
-    for (auto* subchannel_wrapper : chand_->subchannel_wrappers_) {
-      subchannel_wrapper->UpdateHealthCheckServiceName(
-          grpc_core::UniquePtr<char>(
-              gpr_strdup(chand_->health_check_service_name_.get())));
-    }
-    // Save service config.
-    chand_->saved_service_config_ = std::move(service_config);
-  }
-  // Find LB policy config.
-  ProcessLbPolicy(result, parsed_service_config,
-                  &service_config_result.lb_policy_config);
-  grpc_core::UniquePtr<char> lb_policy_name(
-      gpr_strdup((service_config_result.lb_policy_config)->name()));
-  // Swap out the data used by GetChannelInfo().
-  {
-    MutexLock lock(&chand_->info_mu_);
-    chand_->info_lb_policy_name_ = std::move(lb_policy_name);
-    if (service_config_json != nullptr) {
-      chand_->info_service_config_json_ = std::move(service_config_json);
-    }
+    chand_->UpdateServiceConfigInControlPlaneLocked(
+        std::move(service_config), std::move(config_selector),
+        parsed_service_config, service_config_result.lb_policy_config->name());
   }
   // Return results.
   return service_config_result;
 }
 
-void ChannelData::ChannelConfigHelper::ApplyConfigSelector(
-    bool service_config_changed,
-    RefCountedPtr<ConfigSelector> config_selector) {
-  chand_->UpdateServiceConfigInDataPlaneLocked(service_config_changed,
-                                               std::move(config_selector));
+void ChannelData::ChannelConfigHelper::StartUsingServiceConfigForCalls() {
+  chand_->UpdateServiceConfigInDataPlaneLocked();
 }
 
 void ChannelData::ChannelConfigHelper::ResolverTransientFailure(
@@ -1518,21 +1537,19 @@ void ChannelData::ChannelConfigHelper::ResolverTransientFailure(
   chand_->resolver_transient_failure_error_ = error;
 }
 
-void ChannelData::ChannelConfigHelper::ProcessLbPolicy(
+void ChannelData::ChannelConfigHelper::ChooseLbPolicy(
     const Resolver::Result& resolver_result,
     const internal::ClientChannelGlobalParsedConfig* parsed_service_config,
     RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config) {
   // Prefer the LB policy config found in the service config.
-  if (parsed_service_config != nullptr &&
-      parsed_service_config->parsed_lb_config() != nullptr) {
+  if (parsed_service_config->parsed_lb_config() != nullptr) {
     *lb_policy_config = parsed_service_config->parsed_lb_config();
     return;
   }
   // Try the deprecated LB policy name from the service config.
   // If not, try the setting from channel args.
   const char* policy_name = nullptr;
-  if (parsed_service_config != nullptr &&
-      !parsed_service_config->parsed_deprecated_lb_policy().empty()) {
+  if (!parsed_service_config->parsed_deprecated_lb_policy().empty()) {
     policy_name = parsed_service_config->parsed_deprecated_lb_policy().c_str();
   } else {
     const grpc_arg* channel_arg =
@@ -1652,16 +1669,17 @@ ChannelData::ChannelData(grpc_channel_element_args* args, grpc_error** error)
         "filter");
     return;
   }
-  // Get default service config
+  // Get default service config.  If none is specified via the client API,
+  // we use an empty config.
   const char* service_config_json = grpc_channel_arg_get_string(
       grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG));
-  if (service_config_json != nullptr) {
-    *error = GRPC_ERROR_NONE;
-    default_service_config_ = ServiceConfig::Create(service_config_json, error);
-    if (*error != GRPC_ERROR_NONE) {
-      default_service_config_.reset();
-      return;
-    }
+  if (service_config_json == nullptr) service_config_json = "{}";
+  *error = GRPC_ERROR_NONE;
+  default_service_config_ =
+      ServiceConfig::Create(args->channel_args, service_config_json, error);
+  if (*error != GRPC_ERROR_NONE) {
+    default_service_config_.reset();
+    return;
   }
   grpc_uri* uri = grpc_uri_parse(server_uri, true);
   if (uri != nullptr && uri->path[0] != '\0') {
@@ -1675,12 +1693,19 @@ ChannelData::ChannelData(grpc_channel_element_args* args, grpc_error** error)
                                &new_args);
   target_uri_.reset(proxy_name != nullptr ? proxy_name
                                           : gpr_strdup(server_uri));
-  channel_args_ = new_args != nullptr
-                      ? new_args
-                      : grpc_channel_args_copy(args->channel_args);
+  // Strip out service config channel arg, so that it doesn't affect
+  // subchannel uniqueness when the args flow down to that layer.
+  const char* arg_to_remove = GRPC_ARG_SERVICE_CONFIG;
+  channel_args_ = grpc_channel_args_copy_and_remove(
+      new_args != nullptr ? new_args : args->channel_args, &arg_to_remove, 1);
+  grpc_channel_args_destroy(new_args);
+  keepalive_time_ = grpc_channel_args_find_integer(
+      channel_args_, GRPC_ARG_KEEPALIVE_TIME_MS,
+      {-1 /* default value, unset */, 1, INT_MAX});
   if (!ResolverRegistry::IsValidTarget(target_uri_.get())) {
-    *error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("the target uri is not valid.");
+    std::string error_message =
+        absl::StrCat("the target uri is not valid: ", target_uri_.get());
+    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_message.c_str());
     return;
   }
   *error = GRPC_ERROR_NONE;
@@ -1701,17 +1726,17 @@ ChannelData::~ChannelData() {
 }
 
 void ChannelData::UpdateStateAndPickerLocked(
-    grpc_connectivity_state state, const char* reason,
+    grpc_connectivity_state state, const absl::Status& status,
+    const char* reason,
     std::unique_ptr<LoadBalancingPolicy::SubchannelPicker> picker) {
   // Clean the control plane when entering IDLE.
-  if (picker_ == nullptr) {
+  if (picker == nullptr || state == GRPC_CHANNEL_SHUTDOWN) {
     health_check_service_name_.reset();
     saved_service_config_.reset();
     saved_config_selector_.reset();
-    received_first_resolver_result_ = false;
   }
   // Update connectivity state.
-  state_tracker_.SetState(state, reason);
+  state_tracker_.SetState(state, status, reason);
   if (channelz_node_ != nullptr) {
     channelz_node_->SetConnectivityState(state);
     channelz_node_->AddTraceEvent(
@@ -1754,7 +1779,7 @@ void ChannelData::UpdateStateAndPickerLocked(
     // Note: Original value will be destroyed after the lock is released.
     picker_.swap(picker);
     // Clean the data plane if the updated picker is nullptr.
-    if (picker_ == nullptr) {
+    if (picker_ == nullptr || state == GRPC_CHANNEL_SHUTDOWN) {
       received_service_config_data_ = false;
       // Note: We save the objects to unref until after the lock is released.
       retry_throttle_data_to_unref = std::move(retry_throttle_data_);
@@ -1776,43 +1801,72 @@ void ChannelData::UpdateStateAndPickerLocked(
   pending_subchannel_updates_.clear();
 }
 
-void ChannelData::UpdateServiceConfigInDataPlaneLocked(
-    bool service_config_changed,
-    RefCountedPtr<ConfigSelector> config_selector) {
-  // Check if ConfigSelector has changed.
-  const bool config_selector_changed =
-      saved_config_selector_ != config_selector;
-  saved_config_selector_ = config_selector;
-  // We want to set the service config at least once, even if the
-  // resolver does not return a config, because that ensures that we
-  // disable retries if they are not enabled in the service config.
-  // TODO(roth): Consider removing the received_first_resolver_result_ check
-  // when we implement transparent retries.
-  if (!service_config_changed && !config_selector_changed &&
-      received_first_resolver_result_) {
-    return;
+void ChannelData::UpdateServiceConfigInControlPlaneLocked(
+    RefCountedPtr<ServiceConfig> service_config,
+    RefCountedPtr<ConfigSelector> config_selector,
+    const internal::ClientChannelGlobalParsedConfig* parsed_service_config,
+    const char* lb_policy_name) {
+  grpc_core::UniquePtr<char> service_config_json(
+      gpr_strdup(service_config->json_string().c_str()));
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+    gpr_log(GPR_INFO,
+            "chand=%p: resolver returned updated service config: \"%s\"", this,
+            service_config_json.get());
+  }
+  // Save service config.
+  saved_service_config_ = std::move(service_config);
+  // Update health check service name if needed.
+  if (((health_check_service_name_ == nullptr) !=
+       (parsed_service_config->health_check_service_name() == nullptr)) ||
+      (health_check_service_name_ != nullptr &&
+       strcmp(health_check_service_name_.get(),
+              parsed_service_config->health_check_service_name()) != 0)) {
+    health_check_service_name_.reset(
+        gpr_strdup(parsed_service_config->health_check_service_name()));
+    // Update health check service name used by existing subchannel wrappers.
+    for (auto* subchannel_wrapper : subchannel_wrappers_) {
+      subchannel_wrapper->UpdateHealthCheckServiceName(
+          grpc_core::UniquePtr<char>(
+              gpr_strdup(health_check_service_name_.get())));
+    }
   }
-  received_first_resolver_result_ = true;
+  // Swap out the data used by GetChannelInfo().
+  grpc_core::UniquePtr<char> lb_policy_name_owned(gpr_strdup(lb_policy_name));
+  {
+    MutexLock lock(&info_mu_);
+    info_lb_policy_name_ = std::move(lb_policy_name_owned);
+    info_service_config_json_ = std::move(service_config_json);
+  }
+  // Save config selector.
+  saved_config_selector_ = std::move(config_selector);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+    gpr_log(GPR_INFO, "chand=%p: using ConfigSelector %p", this,
+            saved_config_selector_.get());
+  }
+}
+
+void ChannelData::UpdateServiceConfigInDataPlaneLocked() {
   // Get retry throttle data from service config.
+  const internal::ClientChannelGlobalParsedConfig* parsed_service_config =
+      static_cast<const internal::ClientChannelGlobalParsedConfig*>(
+          saved_service_config_->GetGlobalParsedConfig(
+              internal::ClientChannelServiceConfigParser::ParserIndex()));
+  absl::optional<internal::ClientChannelGlobalParsedConfig::RetryThrottling>
+      retry_throttle_config = parsed_service_config->retry_throttling();
   RefCountedPtr<ServerRetryThrottleData> retry_throttle_data;
-  if (saved_service_config_ != nullptr) {
-    const internal::ClientChannelGlobalParsedConfig* parsed_service_config =
-        static_cast<const internal::ClientChannelGlobalParsedConfig*>(
-            saved_service_config_->GetGlobalParsedConfig(
-                internal::ClientChannelServiceConfigParser::ParserIndex()));
-    if (parsed_service_config != nullptr) {
-      absl::optional<internal::ClientChannelGlobalParsedConfig::RetryThrottling>
-          retry_throttle_config = parsed_service_config->retry_throttling();
-      if (retry_throttle_config.has_value()) {
-        retry_throttle_data =
-            internal::ServerRetryThrottleMap::GetDataForServer(
-                server_name_.get(),
-                retry_throttle_config.value().max_milli_tokens,
-                retry_throttle_config.value().milli_token_ratio);
-      }
-    }
+  if (retry_throttle_config.has_value()) {
+    retry_throttle_data = internal::ServerRetryThrottleMap::GetDataForServer(
+        server_name_.get(), retry_throttle_config.value().max_milli_tokens,
+        retry_throttle_config.value().milli_token_ratio);
+  }
+  // Grab ref to service config.
+  RefCountedPtr<ServiceConfig> service_config = saved_service_config_;
+  // Grab ref to config selector.  Use default if resolver didn't supply one.
+  RefCountedPtr<ConfigSelector> config_selector = saved_config_selector_;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_routing_trace)) {
+    gpr_log(GPR_INFO, "chand=%p: switching to ConfigSelector %p", this,
+            saved_config_selector_.get());
   }
-  // Create default config selector if not provided by resolver.
   if (config_selector == nullptr) {
     config_selector =
         MakeRefCounted<DefaultConfigSelector>(saved_service_config_);
@@ -1821,9 +1875,6 @@ void ChannelData::UpdateServiceConfigInDataPlaneLocked(
   //
   // We defer unreffing the old values (and deallocating memory) until
   // after releasing the lock to keep the critical section small.
-  RefCountedPtr<ServiceConfig> service_config_to_unref = saved_service_config_;
-  RefCountedPtr<ConfigSelector> config_selector_to_unref =
-      std::move(config_selector);
   {
     MutexLock lock(&data_plane_mu_);
     GRPC_ERROR_UNREF(resolver_transient_failure_error_);
@@ -1832,8 +1883,8 @@ void ChannelData::UpdateServiceConfigInDataPlaneLocked(
     received_service_config_data_ = true;
     // Old values will be unreffed after lock is released.
     retry_throttle_data_.swap(retry_throttle_data);
-    service_config_.swap(service_config_to_unref);
-    config_selector_.swap(config_selector_to_unref);
+    service_config_.swap(service_config);
+    config_selector_.swap(config_selector);
     // Re-process queued picks.
     for (QueuedPick* pick = queued_picks_; pick != nullptr; pick = pick->next) {
       grpc_call_element* elem = pick->elem;
@@ -1938,8 +1989,8 @@ void ChannelData::StartTransportOpLocked(grpc_transport_op* op) {
         static_cast<grpc_connectivity_state>(value) == GRPC_CHANNEL_IDLE) {
       if (disconnect_error() == GRPC_ERROR_NONE) {
         // Enter IDLE state.
-        UpdateStateAndPickerLocked(GRPC_CHANNEL_IDLE, "channel entering IDLE",
-                                   nullptr);
+        UpdateStateAndPickerLocked(GRPC_CHANNEL_IDLE, absl::Status(),
+                                   "channel entering IDLE", nullptr);
       }
       GRPC_ERROR_UNREF(op->disconnect_with_error);
     } else {
@@ -1948,7 +1999,7 @@ void ChannelData::StartTransportOpLocked(grpc_transport_op* op) {
                  GRPC_ERROR_NONE);
       disconnect_error_.Store(op->disconnect_with_error, MemoryOrder::RELEASE);
       UpdateStateAndPickerLocked(
-          GRPC_CHANNEL_SHUTDOWN, "shutdown from API",
+          GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
           absl::make_unique<LoadBalancingPolicy::TransientFailurePicker>(
               GRPC_ERROR_REF(op->disconnect_with_error)));
     }
@@ -2090,7 +2141,7 @@ void ChannelData::RemoveConnectivityWatcher(
 
 CallData::CallData(grpc_call_element* elem, const ChannelData& chand,
                    const grpc_call_element_args& args)
-    : deadline_state_(elem, args.call_stack, args.call_combiner,
+    : deadline_state_(elem, args,
                       GPR_LIKELY(chand.deadline_checking_enabled())
                           ? args.deadline
                           : GRPC_MILLIS_INF_FUTURE),
@@ -2133,13 +2184,14 @@ void CallData::Destroy(grpc_call_element* elem,
                        const grpc_call_final_info* /*final_info*/,
                        grpc_closure* then_schedule_closure) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (GPR_LIKELY(calld->subchannel_call_ != nullptr)) {
-    calld->subchannel_call_->SetAfterCallStackDestroy(then_schedule_closure);
-    then_schedule_closure = nullptr;
-  }
+  RefCountedPtr<SubchannelCall> subchannel_call = calld->subchannel_call_;
   calld->~CallData();
-  // TODO(yashkt) : This can potentially be a Closure::Run
-  ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, GRPC_ERROR_NONE);
+  if (GPR_LIKELY(subchannel_call != nullptr)) {
+    subchannel_call->SetAfterCallStackDestroy(then_schedule_closure);
+  } else {
+    // TODO(yashkt) : This can potentially be a Closure::Run
+    ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, GRPC_ERROR_NONE);
+  }
 }
 
 void CallData::StartTransportStreamOpBatch(
@@ -3829,6 +3881,7 @@ class CallData::QueuedPickCanceller {
     }
     if (calld->pick_canceller_ == self && error != GRPC_ERROR_NONE) {
       // Remove pick from list of queued picks.
+      calld->MaybeInvokeConfigSelectorCommitCallback();
       calld->MaybeRemoveCallFromQueuedPicksLocked(self->elem_);
       // Fail pending batches on the call.
       calld->PendingBatchesFail(self->elem_, GRPC_ERROR_REF(error),
@@ -3877,8 +3930,7 @@ grpc_error* CallData::ApplyServiceConfigToCallLocked(
             chand, this);
   }
   ConfigSelector* config_selector = chand->config_selector();
-  auto service_config = chand->service_config();
-  if (service_config != nullptr) {
+  if (config_selector != nullptr) {
     // Use the ConfigSelector to determine the config for the call.
     ConfigSelector::CallConfig call_config =
         config_selector->GetCallConfig({&path_, initial_metadata, arena_});
@@ -3891,7 +3943,8 @@ grpc_error* CallData::ApplyServiceConfigToCallLocked(
     // so that it can be accessed by filters in the subchannel, and it
     // will be cleaned up when the call ends.
     auto* service_config_call_data = arena_->New<ServiceConfigCallData>(
-        std::move(service_config), call_config.method_configs, call_context_);
+        std::move(call_config.service_config), call_config.method_configs,
+        call_context_);
     // Apply our own method params to the call.
     method_params_ = static_cast<ClientChannelMethodParsedConfig*>(
         service_config_call_data->GetMethodParsedConfig(
@@ -4118,7 +4171,9 @@ bool CallData::PickSubchannelLocked(grpc_call_element* elem,
         connected_subchannel_ =
             chand->GetConnectedSubchannelInDataPlane(result.subchannel.get());
         GPR_ASSERT(connected_subchannel_ != nullptr);
-        if (retry_committed_) MaybeInvokeConfigSelectorCommitCallback();
+        if (!enable_retries_ || retry_committed_) {
+          MaybeInvokeConfigSelectorCommitCallback();
+        }
       }
       lb_recv_trailing_metadata_ready_ = result.recv_trailing_metadata_ready;
       *error = result.error;