Merge branch 'master' into enable-deadline-propagation

BUILD

@@ -68,6 +68,11 @@ config_setting(
     values = {"python_path": "python3"},
 )
 
+config_setting(
+    name = "mac_x86_64",
+    values = {"cpu": "darwin"},
+)
+
 # This should be updated along with build.yaml
 g_stands_for = "godric"
 
@@ -355,6 +360,7 @@ grpc_cc_library(
         "gpr",
         "grpc",
         "grpc++_base",
+        "grpc_cfstream",
         "grpc++_codegen_base",
         "grpc++_codegen_base_src",
         "grpc++_codegen_proto",
@@ -618,10 +624,6 @@ grpc_cc_library(
 
 grpc_cc_library(
     name = "atomic",
-    hdrs = [
-        "src/core/lib/gprpp/atomic_with_atm.h",
-        "src/core/lib/gprpp/atomic_with_std.h",
-    ],
     language = "c++",
     public_hdrs = [
         "src/core/lib/gprpp/atomic.h",
@@ -677,6 +679,7 @@ grpc_cc_library(
     language = "c++",
     public_hdrs = ["src/core/lib/gprpp/ref_counted.h"],
     deps = [
+        "atomic",
         "debug_location",
         "gpr_base",
         "grpc_trace",
@@ -986,6 +989,7 @@ grpc_cc_library(
     ],
     language = "c++",
     public_hdrs = GRPC_PUBLIC_HDRS,
+    use_cfstream = True,
     deps = [
         "gpr_base",
         "grpc_codegen",
@@ -1049,6 +1053,7 @@ grpc_cc_library(
         "src/core/lib/iomgr/endpoint_cfstream.h",
         "src/core/lib/iomgr/error_cfstream.h",
     ],
+    use_cfstream = True,
     deps = [
         ":gpr_base",
         ":grpc_base",
@@ -1075,10 +1080,10 @@ grpc_cc_library(
         "src/core/ext/filters/client_channel/parse_address.cc",
         "src/core/ext/filters/client_channel/proxy_mapper.cc",
         "src/core/ext/filters/client_channel/proxy_mapper_registry.cc",
-        "src/core/ext/filters/client_channel/request_routing.cc",
         "src/core/ext/filters/client_channel/resolver.cc",
         "src/core/ext/filters/client_channel/resolver_registry.cc",
         "src/core/ext/filters/client_channel/resolver_result_parsing.cc",
+        "src/core/ext/filters/client_channel/resolving_lb_policy.cc",
         "src/core/ext/filters/client_channel/retry_throttle.cc",
         "src/core/ext/filters/client_channel/server_address.cc",
         "src/core/ext/filters/client_channel/subchannel.cc",
@@ -1101,11 +1106,11 @@ grpc_cc_library(
         "src/core/ext/filters/client_channel/parse_address.h",
         "src/core/ext/filters/client_channel/proxy_mapper.h",
         "src/core/ext/filters/client_channel/proxy_mapper_registry.h",
-        "src/core/ext/filters/client_channel/request_routing.h",
         "src/core/ext/filters/client_channel/resolver.h",
         "src/core/ext/filters/client_channel/resolver_factory.h",
         "src/core/ext/filters/client_channel/resolver_registry.h",
         "src/core/ext/filters/client_channel/resolver_result_parsing.h",
+        "src/core/ext/filters/client_channel/resolving_lb_policy.h",
         "src/core/ext/filters/client_channel/retry_throttle.h",
         "src/core/ext/filters/client_channel/server_address.h",
         "src/core/ext/filters/client_channel/subchannel.h",

CMakeLists.txt

@@ -1239,10 +1239,10 @@ add_library(grpc
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -1594,10 +1594,10 @@ add_library(grpc_cronet
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -1972,10 +1972,10 @@ add_library(grpc_test_util
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -2297,10 +2297,10 @@ add_library(grpc_test_util_unsecure
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -2633,10 +2633,10 @@ add_library(grpc_unsecure
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -3490,10 +3490,10 @@ add_library(grpc++_cronet
   src/core/ext/filters/client_channel/parse_address.cc
   src/core/ext/filters/client_channel/proxy_mapper.cc
   src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  src/core/ext/filters/client_channel/request_routing.cc
   src/core/ext/filters/client_channel/resolver.cc
   src/core/ext/filters/client_channel/resolver_registry.cc
   src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  src/core/ext/filters/client_channel/resolving_lb_policy.cc
   src/core/ext/filters/client_channel/retry_throttle.cc
   src/core/ext/filters/client_channel/server_address.cc
   src/core/ext/filters/client_channel/subchannel.cc
@@ -12441,6 +12441,7 @@ if (gRPC_BUILD_TESTS)
 
 add_executable(client_callback_end2end_test
   test/cpp/end2end/client_callback_end2end_test.cc
+  test/cpp/end2end/interceptors_util.cc
   third_party/googletest/googletest/src/gtest-all.cc
   third_party/googletest/googlemock/src/gmock-all.cc
 )

Makefile

@@ -3758,10 +3758,10 @@ LIBGRPC_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -4107,10 +4107,10 @@ LIBGRPC_CRONET_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -4478,10 +4478,10 @@ LIBGRPC_TEST_UTIL_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -4790,10 +4790,10 @@ LIBGRPC_TEST_UTIL_UNSECURE_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -5100,10 +5100,10 @@ LIBGRPC_UNSECURE_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -5934,10 +5934,10 @@ LIBGRPC++_CRONET_SRC = \
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \
@@ -17464,6 +17464,7 @@ endif
 
 CLIENT_CALLBACK_END2END_TEST_SRC = \
     test/cpp/end2end/client_callback_end2end_test.cc \
+    test/cpp/end2end/interceptors_util.cc \
 
 CLIENT_CALLBACK_END2END_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(CLIENT_CALLBACK_END2END_TEST_SRC))))
 ifeq ($(NO_SECURE),true)
@@ -17496,6 +17497,8 @@ endif
 
 $(OBJDIR)/$(CONFIG)/test/cpp/end2end/client_callback_end2end_test.o:  $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a
 
+$(OBJDIR)/$(CONFIG)/test/cpp/end2end/interceptors_util.o:  $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
 deps_client_callback_end2end_test: $(CLIENT_CALLBACK_END2END_TEST_OBJS:.o=.dep)
 
 ifneq ($(NO_SECURE),true)

bazel/generate_cc.bzl

@@ -28,7 +28,7 @@ def generate_cc_impl(ctx):
   else:
     outs += [proto.path[label_len:-len(".proto")] + ".pb.h" for proto in protos]
     outs += [proto.path[label_len:-len(".proto")] + ".pb.cc" for proto in protos]
-  out_files = [ctx.new_file(out) for out in outs]
+  out_files = [ctx.actions.declare_file(out) for out in outs]
   dir_out = str(ctx.genfiles_dir.path + proto_root)
 
   arguments = []
@@ -38,10 +38,10 @@ def generate_cc_impl(ctx):
     if ctx.attr.generate_mocks:
       flags.append("generate_mock_code=true")
     arguments += ["--PLUGIN_out=" + ",".join(flags) + ":" + dir_out]
-    additional_input = [ctx.executable.plugin]
+    tools = [ctx.executable.plugin]
   else:
     arguments += ["--cpp_out=" + ",".join(ctx.attr.flags) + ":" + dir_out]
-    additional_input = []
+    tools = []
 
   # Import protos relative to their workspace root so that protoc prints the
   # right include paths.
@@ -70,8 +70,9 @@ def generate_cc_impl(ctx):
       arguments += ["-I{0}".format(f + "/../..")]
       well_known_proto_files = [f for f in ctx.attr.well_known_protos.files]
 
-  ctx.action(
-      inputs = protos + includes + additional_input + well_known_proto_files,
+  ctx.actions.run(
+      inputs = protos + includes + well_known_proto_files,
+      tools = tools,
       outputs = out_files,
       executable = ctx.executable._protoc,
       arguments = arguments,

bazel/grpc_build_system.bzl

@@ -35,6 +35,12 @@ def if_not_windows(a):
         "//conditions:default": a,
     })
 
+def if_mac(a):
+    return select({
+        "//:mac_x86_64": a,
+        "//conditions:default": [],
+    })
+
 def _get_external_deps(external_deps):
     ret = []
     for dep in external_deps:
@@ -73,10 +79,16 @@ def grpc_cc_library(
         testonly = False,
         visibility = None,
         alwayslink = 0,
-        data = []):
+        data = [],
+        use_cfstream = False):
     copts = []
+    if use_cfstream:
+        copts = if_mac(["-DGRPC_CFSTREAM"])
     if language.upper() == "C":
-        copts = if_not_windows(["-std=c99"])
+        copts = copts + if_not_windows(["-std=c99"])
+    linkopts = if_not_windows(["-pthread"])
+    if use_cfstream:
+        linkopts = linkopts + if_mac(["-framework CoreFoundation"])
     native.cc_library(
         name = name,
         srcs = srcs,
@@ -98,7 +110,7 @@ def grpc_cc_library(
         copts = copts,
         visibility = visibility,
         testonly = testonly,
-        linkopts = if_not_windows(["-pthread"]),
+        linkopts = linkopts,
         includes = [
             "include",
         ],
@@ -113,7 +125,6 @@ def grpc_proto_plugin(name, srcs = [], deps = []):
         deps = deps,
     )
 
-
 def grpc_proto_library(
         name,
         srcs = [],
@@ -133,9 +144,9 @@ def grpc_proto_library(
     )
 
 def grpc_cc_test(name, srcs = [], deps = [], external_deps = [], args = [], data = [], uses_polling = True, language = "C++", size = "medium", timeout = None, tags = [], exec_compatible_with = []):
-    copts = []
+    copts = if_mac(["-DGRPC_CFSTREAM"])
     if language.upper() == "C":
-        copts = if_not_windows(["-std=c99"])
+        copts = copts + if_not_windows(["-std=c99"])
     args = {
         "name": name,
         "srcs": srcs,

bazel/grpc_deps.bzl

@@ -170,8 +170,8 @@ def grpc_deps():
     if "com_google_absl" not in native.existing_rules():
         http_archive(
             name = "com_google_absl",
-            strip_prefix = "abseil-cpp-cd95e71df6eaf8f2a282b1da556c2cf1c9b09207",
-            url = "https://github.com/abseil/abseil-cpp/archive/cd95e71df6eaf8f2a282b1da556c2cf1c9b09207.tar.gz",
+            strip_prefix = "abseil-cpp-308ce31528a7edfa39f5f6d36142278a0ae1bf45",
+            url = "https://github.com/abseil/abseil-cpp/archive/308ce31528a7edfa39f5f6d36142278a0ae1bf45.tar.gz",
         )
 
     if "com_github_bazelbuild_bazeltoolchains" not in native.existing_rules():
@@ -196,8 +196,8 @@ def grpc_deps():
     if "io_opencensus_cpp" not in native.existing_rules():
         http_archive(
             name = "io_opencensus_cpp",
-            strip_prefix = "opencensus-cpp-fdf0f308b1631bb4a942e32ba5d22536a6170274",
-            url = "https://github.com/census-instrumentation/opencensus-cpp/archive/fdf0f308b1631bb4a942e32ba5d22536a6170274.tar.gz",
+            strip_prefix = "opencensus-cpp-03dff0352522983ffdee48cedbf87cbe37f1bb7f",
+            url = "https://github.com/census-instrumentation/opencensus-cpp/archive/03dff0352522983ffdee48cedbf87cbe37f1bb7f.tar.gz",
         )
 
     if "upb" not in native.existing_rules():

build.yaml

@@ -192,8 +192,6 @@ filegroups:
   - src/core/lib/gpr/useful.h
   - src/core/lib/gprpp/abstract.h
   - src/core/lib/gprpp/atomic.h
-  - src/core/lib/gprpp/atomic_with_atm.h
-  - src/core/lib/gprpp/atomic_with_std.h
   - src/core/lib/gprpp/fork.h
   - src/core/lib/gprpp/manual_constructor.h
   - src/core/lib/gprpp/memory.h
@@ -587,11 +585,11 @@ filegroups:
   - src/core/ext/filters/client_channel/parse_address.h
   - src/core/ext/filters/client_channel/proxy_mapper.h
   - src/core/ext/filters/client_channel/proxy_mapper_registry.h
-  - src/core/ext/filters/client_channel/request_routing.h
   - src/core/ext/filters/client_channel/resolver.h
   - src/core/ext/filters/client_channel/resolver_factory.h
   - src/core/ext/filters/client_channel/resolver_registry.h
   - src/core/ext/filters/client_channel/resolver_result_parsing.h
+  - src/core/ext/filters/client_channel/resolving_lb_policy.h
   - src/core/ext/filters/client_channel/retry_throttle.h
   - src/core/ext/filters/client_channel/server_address.h
   - src/core/ext/filters/client_channel/subchannel.h
@@ -614,10 +612,10 @@ filegroups:
   - src/core/ext/filters/client_channel/parse_address.cc
   - src/core/ext/filters/client_channel/proxy_mapper.cc
   - src/core/ext/filters/client_channel/proxy_mapper_registry.cc
-  - src/core/ext/filters/client_channel/request_routing.cc
   - src/core/ext/filters/client_channel/resolver.cc
   - src/core/ext/filters/client_channel/resolver_registry.cc
   - src/core/ext/filters/client_channel/resolver_result_parsing.cc
+  - src/core/ext/filters/client_channel/resolving_lb_policy.cc
   - src/core/ext/filters/client_channel/retry_throttle.cc
   - src/core/ext/filters/client_channel/server_address.cc
   - src/core/ext/filters/client_channel/subchannel.cc
@@ -4470,6 +4468,7 @@ targets:
   language: c++
   src:
   - test/cpp/end2end/client_callback_end2end_test.cc
+  - test/cpp/end2end/interceptors_util.cc
   deps:
   - grpc++_test_util
   - grpc_test_util

config.m4

@@ -355,10 +355,10 @@ if test "$PHP_GRPC" != "no"; then
     src/core/ext/filters/client_channel/parse_address.cc \
     src/core/ext/filters/client_channel/proxy_mapper.cc \
     src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
-    src/core/ext/filters/client_channel/request_routing.cc \
     src/core/ext/filters/client_channel/resolver.cc \
     src/core/ext/filters/client_channel/resolver_registry.cc \
     src/core/ext/filters/client_channel/resolver_result_parsing.cc \
+    src/core/ext/filters/client_channel/resolving_lb_policy.cc \
     src/core/ext/filters/client_channel/retry_throttle.cc \
     src/core/ext/filters/client_channel/server_address.cc \
     src/core/ext/filters/client_channel/subchannel.cc \

config.w32

@@ -330,10 +330,10 @@ if (PHP_GRPC != "no") {
     "src\\core\\ext\\filters\\client_channel\\parse_address.cc " +
     "src\\core\\ext\\filters\\client_channel\\proxy_mapper.cc " +
     "src\\core\\ext\\filters\\client_channel\\proxy_mapper_registry.cc " +
-    "src\\core\\ext\\filters\\client_channel\\request_routing.cc " +
     "src\\core\\ext\\filters\\client_channel\\resolver.cc " +
     "src\\core\\ext\\filters\\client_channel\\resolver_registry.cc " +
     "src\\core\\ext\\filters\\client_channel\\resolver_result_parsing.cc " +
+    "src\\core\\ext\\filters\\client_channel\\resolving_lb_policy.cc " +
     "src\\core\\ext\\filters\\client_channel\\retry_throttle.cc " +
     "src\\core\\ext\\filters\\client_channel\\server_address.cc " +
     "src\\core\\ext\\filters\\client_channel\\subchannel.cc " +

doc/environment_variables.md

@@ -41,6 +41,9 @@ some configuration as environment variables that can be set.
   - bdp_estimator - traces behavior of bdp estimation logic
   - call_combiner - traces call combiner state
   - call_error - traces the possible errors contributing to final call status
+  - cares_resolver - traces operations of the c-ares based DNS resolver
+  - cares_address_sorting - traces operations of the c-ares based DNS
+    resolver's resolved address sorter
   - channel - traces operations on the C core channel stack
   - client_channel - traces client channel activity, including resolver
     and load balancing policy interaction

doc/server_reflection_tutorial.md

@@ -15,8 +15,8 @@ server reflection, you can link this library to your server binary.
 
 Some platforms (e.g. Ubuntu 11.10 onwards) only link in libraries that directly
 contain symbols used by the application. On these platforms, LD flag
-`--no-as-needed` is needed for for dynamic linking and `--whole-archive` is
-needed for for static linking.
+`--no-as-needed` is needed for dynamic linking and `--whole-archive` is
+needed for static linking.
 
 This [Makefile](../examples/cpp/helloworld/Makefile#L37#L45) demonstrates
 enabling c++ server reflection on Linux and MacOS.

gRPC-C++.podspec

@@ -251,8 +251,6 @@ Pod::Spec.new do |s|
                       'src/core/lib/gpr/useful.h',
                       'src/core/lib/gprpp/abstract.h',
                       'src/core/lib/gprpp/atomic.h',
-                      'src/core/lib/gprpp/atomic_with_atm.h',
-                      'src/core/lib/gprpp/atomic_with_std.h',
                       'src/core/lib/gprpp/fork.h',
                       'src/core/lib/gprpp/manual_constructor.h',
                       'src/core/lib/gprpp/memory.h',
@@ -360,11 +358,11 @@ Pod::Spec.new do |s|
                       'src/core/ext/filters/client_channel/parse_address.h',
                       'src/core/ext/filters/client_channel/proxy_mapper.h',
                       'src/core/ext/filters/client_channel/proxy_mapper_registry.h',
-                      'src/core/ext/filters/client_channel/request_routing.h',
                       'src/core/ext/filters/client_channel/resolver.h',
                       'src/core/ext/filters/client_channel/resolver_factory.h',
                       'src/core/ext/filters/client_channel/resolver_registry.h',
                       'src/core/ext/filters/client_channel/resolver_result_parsing.h',
+                      'src/core/ext/filters/client_channel/resolving_lb_policy.h',
                       'src/core/ext/filters/client_channel/retry_throttle.h',
                       'src/core/ext/filters/client_channel/server_address.h',
                       'src/core/ext/filters/client_channel/subchannel.h',
@@ -567,8 +565,6 @@ Pod::Spec.new do |s|
                               'src/core/lib/gpr/useful.h',
                               'src/core/lib/gprpp/abstract.h',
                               'src/core/lib/gprpp/atomic.h',
-                              'src/core/lib/gprpp/atomic_with_atm.h',
-                              'src/core/lib/gprpp/atomic_with_std.h',
                               'src/core/lib/gprpp/fork.h',
                               'src/core/lib/gprpp/manual_constructor.h',
                               'src/core/lib/gprpp/memory.h',

gRPC-Core.podspec

@@ -206,8 +206,6 @@ Pod::Spec.new do |s|
                       'src/core/lib/gpr/useful.h',
                       'src/core/lib/gprpp/abstract.h',
                       'src/core/lib/gprpp/atomic.h',
-                      'src/core/lib/gprpp/atomic_with_atm.h',
-                      'src/core/lib/gprpp/atomic_with_std.h',
                       'src/core/lib/gprpp/fork.h',
                       'src/core/lib/gprpp/manual_constructor.h',
                       'src/core/lib/gprpp/memory.h',
@@ -354,11 +352,11 @@ Pod::Spec.new do |s|
                       'src/core/ext/filters/client_channel/parse_address.h',
                       'src/core/ext/filters/client_channel/proxy_mapper.h',
                       'src/core/ext/filters/client_channel/proxy_mapper_registry.h',
-                      'src/core/ext/filters/client_channel/request_routing.h',
                       'src/core/ext/filters/client_channel/resolver.h',
                       'src/core/ext/filters/client_channel/resolver_factory.h',
                       'src/core/ext/filters/client_channel/resolver_registry.h',
                       'src/core/ext/filters/client_channel/resolver_result_parsing.h',
+                      'src/core/ext/filters/client_channel/resolving_lb_policy.h',
                       'src/core/ext/filters/client_channel/retry_throttle.h',
                       'src/core/ext/filters/client_channel/server_address.h',
                       'src/core/ext/filters/client_channel/subchannel.h',
@@ -801,10 +799,10 @@ Pod::Spec.new do |s|
                       'src/core/ext/filters/client_channel/parse_address.cc',
                       'src/core/ext/filters/client_channel/proxy_mapper.cc',
                       'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-                      'src/core/ext/filters/client_channel/request_routing.cc',
                       'src/core/ext/filters/client_channel/resolver.cc',
                       'src/core/ext/filters/client_channel/resolver_registry.cc',
                       'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+                      'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
                       'src/core/ext/filters/client_channel/retry_throttle.cc',
                       'src/core/ext/filters/client_channel/server_address.cc',
                       'src/core/ext/filters/client_channel/subchannel.cc',
@@ -875,8 +873,6 @@ Pod::Spec.new do |s|
                               'src/core/lib/gpr/useful.h',
                               'src/core/lib/gprpp/abstract.h',
                               'src/core/lib/gprpp/atomic.h',
-                              'src/core/lib/gprpp/atomic_with_atm.h',
-                              'src/core/lib/gprpp/atomic_with_std.h',
                               'src/core/lib/gprpp/fork.h',
                               'src/core/lib/gprpp/manual_constructor.h',
                               'src/core/lib/gprpp/memory.h',
@@ -984,11 +980,11 @@ Pod::Spec.new do |s|
                               'src/core/ext/filters/client_channel/parse_address.h',
                               'src/core/ext/filters/client_channel/proxy_mapper.h',
                               'src/core/ext/filters/client_channel/proxy_mapper_registry.h',
-                              'src/core/ext/filters/client_channel/request_routing.h',
                               'src/core/ext/filters/client_channel/resolver.h',
                               'src/core/ext/filters/client_channel/resolver_factory.h',
                               'src/core/ext/filters/client_channel/resolver_registry.h',
                               'src/core/ext/filters/client_channel/resolver_result_parsing.h',
+                              'src/core/ext/filters/client_channel/resolving_lb_policy.h',
                               'src/core/ext/filters/client_channel/retry_throttle.h',
                               'src/core/ext/filters/client_channel/server_address.h',
                               'src/core/ext/filters/client_channel/subchannel.h',

grpc.gemspec

@@ -100,8 +100,6 @@ Gem::Specification.new do |s|
   s.files += %w( src/core/lib/gpr/useful.h )
   s.files += %w( src/core/lib/gprpp/abstract.h )
   s.files += %w( src/core/lib/gprpp/atomic.h )
-  s.files += %w( src/core/lib/gprpp/atomic_with_atm.h )
-  s.files += %w( src/core/lib/gprpp/atomic_with_std.h )
   s.files += %w( src/core/lib/gprpp/fork.h )
   s.files += %w( src/core/lib/gprpp/manual_constructor.h )
   s.files += %w( src/core/lib/gprpp/memory.h )
@@ -288,11 +286,11 @@ Gem::Specification.new do |s|
   s.files += %w( src/core/ext/filters/client_channel/parse_address.h )
   s.files += %w( src/core/ext/filters/client_channel/proxy_mapper.h )
   s.files += %w( src/core/ext/filters/client_channel/proxy_mapper_registry.h )
-  s.files += %w( src/core/ext/filters/client_channel/request_routing.h )
   s.files += %w( src/core/ext/filters/client_channel/resolver.h )
   s.files += %w( src/core/ext/filters/client_channel/resolver_factory.h )
   s.files += %w( src/core/ext/filters/client_channel/resolver_registry.h )
   s.files += %w( src/core/ext/filters/client_channel/resolver_result_parsing.h )
+  s.files += %w( src/core/ext/filters/client_channel/resolving_lb_policy.h )
   s.files += %w( src/core/ext/filters/client_channel/retry_throttle.h )
   s.files += %w( src/core/ext/filters/client_channel/server_address.h )
   s.files += %w( src/core/ext/filters/client_channel/subchannel.h )
@@ -738,10 +736,10 @@ Gem::Specification.new do |s|
   s.files += %w( src/core/ext/filters/client_channel/parse_address.cc )
   s.files += %w( src/core/ext/filters/client_channel/proxy_mapper.cc )
   s.files += %w( src/core/ext/filters/client_channel/proxy_mapper_registry.cc )
-  s.files += %w( src/core/ext/filters/client_channel/request_routing.cc )
   s.files += %w( src/core/ext/filters/client_channel/resolver.cc )
   s.files += %w( src/core/ext/filters/client_channel/resolver_registry.cc )
   s.files += %w( src/core/ext/filters/client_channel/resolver_result_parsing.cc )
+  s.files += %w( src/core/ext/filters/client_channel/resolving_lb_policy.cc )
   s.files += %w( src/core/ext/filters/client_channel/retry_throttle.cc )
   s.files += %w( src/core/ext/filters/client_channel/server_address.cc )
   s.files += %w( src/core/ext/filters/client_channel/subchannel.cc )

grpc.gyp

@@ -537,10 +537,10 @@
         'src/core/ext/filters/client_channel/parse_address.cc',
         'src/core/ext/filters/client_channel/proxy_mapper.cc',
         'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-        'src/core/ext/filters/client_channel/request_routing.cc',
         'src/core/ext/filters/client_channel/resolver.cc',
         'src/core/ext/filters/client_channel/resolver_registry.cc',
         'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+        'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
         'src/core/ext/filters/client_channel/retry_throttle.cc',
         'src/core/ext/filters/client_channel/server_address.cc',
         'src/core/ext/filters/client_channel/subchannel.cc',
@@ -801,10 +801,10 @@
         'src/core/ext/filters/client_channel/parse_address.cc',
         'src/core/ext/filters/client_channel/proxy_mapper.cc',
         'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-        'src/core/ext/filters/client_channel/request_routing.cc',
         'src/core/ext/filters/client_channel/resolver.cc',
         'src/core/ext/filters/client_channel/resolver_registry.cc',
         'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+        'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
         'src/core/ext/filters/client_channel/retry_throttle.cc',
         'src/core/ext/filters/client_channel/server_address.cc',
         'src/core/ext/filters/client_channel/subchannel.cc',
@@ -1046,10 +1046,10 @@
         'src/core/ext/filters/client_channel/parse_address.cc',
         'src/core/ext/filters/client_channel/proxy_mapper.cc',
         'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-        'src/core/ext/filters/client_channel/request_routing.cc',
         'src/core/ext/filters/client_channel/resolver.cc',
         'src/core/ext/filters/client_channel/resolver_registry.cc',
         'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+        'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
         'src/core/ext/filters/client_channel/retry_throttle.cc',
         'src/core/ext/filters/client_channel/server_address.cc',
         'src/core/ext/filters/client_channel/subchannel.cc',
@@ -1302,10 +1302,10 @@
         'src/core/ext/filters/client_channel/parse_address.cc',
         'src/core/ext/filters/client_channel/proxy_mapper.cc',
         'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-        'src/core/ext/filters/client_channel/request_routing.cc',
         'src/core/ext/filters/client_channel/resolver.cc',
         'src/core/ext/filters/client_channel/resolver_registry.cc',
         'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+        'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
         'src/core/ext/filters/client_channel/retry_throttle.cc',
         'src/core/ext/filters/client_channel/server_address.cc',
         'src/core/ext/filters/client_channel/subchannel.cc',

include/grpcpp/impl/codegen/client_callback.h

@@ -268,9 +268,8 @@ class ClientCallbackReaderWriterImpl
     // This call initiates two batches, plus any backlog, each with a callback
     // 1. Send initial metadata (unless corked) + recv initial metadata
     // 2. Any read backlog
-    // 3. Recv trailing metadata, on_completion callback
-    // 4. Any write backlog
-    // 5. See if the call can finish (if other callbacks were triggered already)
+    // 3. Any write backlog
+    // 4. Recv trailing metadata, on_completion callback
     started_ = true;
 
     start_tag_.Set(call_.call(),
@@ -308,12 +307,6 @@ class ClientCallbackReaderWriterImpl
       call_.PerformOps(&read_ops_);
     }
 
-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
-                    &finish_ops_);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-    call_.PerformOps(&finish_ops_);
-
     if (write_ops_at_start_) {
       call_.PerformOps(&write_ops_);
     }
@@ -321,7 +314,12 @@ class ClientCallbackReaderWriterImpl
     if (writes_done_ops_at_start_) {
       call_.PerformOps(&writes_done_ops_);
     }
-    MaybeFinish();
+
+    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+                    &finish_ops_);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+    call_.PerformOps(&finish_ops_);
   }
 
   void Read(Response* msg) override {
@@ -414,8 +412,8 @@ class ClientCallbackReaderWriterImpl
   CallbackWithSuccessTag read_tag_;
   bool read_ops_at_start_{false};
 
-  // Minimum of 3 callbacks to pre-register for StartCall, start, and finish
-  std::atomic_int callbacks_outstanding_{3};
+  // Minimum of 2 callbacks to pre-register for start and finish
+  std::atomic_int callbacks_outstanding_{2};
   bool started_{false};
 };
 
@@ -468,7 +466,6 @@ class ClientCallbackReaderImpl
     // 1. Send initial metadata (unless corked) + recv initial metadata
     // 2. Any backlog
     // 3. Recv trailing metadata, on_completion callback
-    // 4. See if the call can finish (if other callbacks were triggered already)
     started_ = true;
 
     start_tag_.Set(call_.call(),
@@ -500,8 +497,6 @@ class ClientCallbackReaderImpl
     finish_ops_.ClientRecvStatus(context_, &finish_status_);
     finish_ops_.set_core_cq_tag(&finish_tag_);
     call_.PerformOps(&finish_ops_);
-
-    MaybeFinish();
   }
 
   void Read(Response* msg) override {
@@ -545,8 +540,8 @@ class ClientCallbackReaderImpl
   CallbackWithSuccessTag read_tag_;
   bool read_ops_at_start_{false};
 
-  // Minimum of 3 callbacks to pre-register for StartCall, start, and finish
-  std::atomic_int callbacks_outstanding_{3};
+  // Minimum of 2 callbacks to pre-register for start and finish
+  std::atomic_int callbacks_outstanding_{2};
   bool started_{false};
 };
 
@@ -597,9 +592,8 @@ class ClientCallbackWriterImpl
   void StartCall() override {
     // This call initiates two batches, plus any backlog, each with a callback
     // 1. Send initial metadata (unless corked) + recv initial metadata
-    // 2. Recv trailing metadata, on_completion callback
-    // 3. Any backlog
-    // 4. See if the call can finish (if other callbacks were triggered already)
+    // 2. Any backlog
+    // 3. Recv trailing metadata, on_completion callback
     started_ = true;
 
     start_tag_.Set(call_.call(),
@@ -626,12 +620,6 @@ class ClientCallbackWriterImpl
                    &write_ops_);
     write_ops_.set_core_cq_tag(&write_tag_);
 
-    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
-                    &finish_ops_);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-    call_.PerformOps(&finish_ops_);
-
     if (write_ops_at_start_) {
       call_.PerformOps(&write_ops_);
     }
@@ -640,7 +628,11 @@ class ClientCallbackWriterImpl
       call_.PerformOps(&writes_done_ops_);
     }
 
-    MaybeFinish();
+    finish_tag_.Set(call_.call(), [this](bool ok) { MaybeFinish(); },
+                    &finish_ops_);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+    call_.PerformOps(&finish_ops_);
   }
 
   void Write(const Request* msg, WriteOptions options) override {
@@ -722,8 +714,8 @@ class ClientCallbackWriterImpl
   CallbackWithSuccessTag writes_done_tag_;
   bool writes_done_ops_at_start_{false};
 
-  // Minimum of 3 callbacks to pre-register for StartCall, start, and finish
-  std::atomic_int callbacks_outstanding_{3};
+  // Minimum of 2 callbacks to pre-register for start and finish
+  std::atomic_int callbacks_outstanding_{2};
   bool started_{false};
 };
 

include/grpcpp/impl/codegen/client_interceptor.h

@@ -76,7 +76,7 @@ class ClientRpcInfo {
     UNKNOWN  // UNKNOWN is not API and will be removed later
   };
 
-  ~ClientRpcInfo(){};
+  ~ClientRpcInfo() {}
 
   // Delete copy constructor but allow default move constructor
   ClientRpcInfo(const ClientRpcInfo&) = delete;

include/grpcpp/impl/codegen/interceptor.h

@@ -90,7 +90,7 @@ enum class InterceptionHookPoints {
 ///   5. Set some fields of an RPC at each interception point, when possible
 class InterceptorBatchMethods {
  public:
-  virtual ~InterceptorBatchMethods(){};
+  virtual ~InterceptorBatchMethods() {}
   /// Determine whether the current batch has an interception hook point
   /// of type \a type
   virtual bool QueryInterceptionHookPoint(InterceptionHookPoints type) = 0;

include/grpcpp/impl/codegen/server_callback.h

@@ -102,7 +102,7 @@ class ServerCallbackWriter {
     // Default implementation that can/should be overridden
     Write(msg, std::move(options));
     Finish(std::move(s));
-  };
+  }
 
  protected:
   template <class Request>
@@ -125,7 +125,7 @@ class ServerCallbackReaderWriter {
     // Default implementation that can/should be overridden
     Write(msg, std::move(options));
     Finish(std::move(s));
-  };
+  }
 
  protected:
   void BindReactor(ServerBidiReactor<Request, Response>* reactor) {

include/grpcpp/impl/codegen/server_interceptor.h

@@ -60,7 +60,7 @@ class ServerRpcInfo {
   /// Type categorizes RPCs by unary or streaming type
   enum class Type { UNARY, CLIENT_STREAMING, SERVER_STREAMING, BIDI_STREAMING };
 
-  ~ServerRpcInfo(){};
+  ~ServerRpcInfo() {}
 
   // Delete all copy and move constructors and assignments
   ServerRpcInfo(const ServerRpcInfo&) = delete;

include/grpcpp/security/credentials.h

@@ -95,7 +95,7 @@ class ChannelCredentials : private GrpcLibraryCodegen {
           std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) {
     return nullptr;
-  };
+  }
 };
 
 /// A call credentials object encapsulates the state needed by a client to

include/grpcpp/server.h

@@ -189,7 +189,7 @@ class Server : public ServerInterface, private GrpcLibraryCodegen {
   /// \param num_cqs How many completion queues does \a cqs hold.
   void Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
 
-  grpc_server* server() override { return server_; };
+  grpc_server* server() override { return server_; }
 
  private:
   std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
@@ -223,7 +223,7 @@ class Server : public ServerInterface, private GrpcLibraryCodegen {
 
   int max_receive_message_size() const override {
     return max_receive_message_size_;
-  };
+  }
 
   CompletionQueue* CallbackCQ() override;
 

package.xml

@@ -105,8 +105,6 @@
     <file baseinstalldir="/" name="src/core/lib/gpr/useful.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/gprpp/abstract.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/gprpp/atomic.h" role="src" />
-    <file baseinstalldir="/" name="src/core/lib/gprpp/atomic_with_atm.h" role="src" />
-    <file baseinstalldir="/" name="src/core/lib/gprpp/atomic_with_std.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/gprpp/fork.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/gprpp/manual_constructor.h" role="src" />
     <file baseinstalldir="/" name="src/core/lib/gprpp/memory.h" role="src" />
@@ -293,11 +291,11 @@
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/parse_address.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/proxy_mapper.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/proxy_mapper_registry.h" role="src" />
-    <file baseinstalldir="/" name="src/core/ext/filters/client_channel/request_routing.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver_factory.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver_registry.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver_result_parsing.h" role="src" />
+    <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolving_lb_policy.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/retry_throttle.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/server_address.h" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/subchannel.h" role="src" />
@@ -743,10 +741,10 @@
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/parse_address.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/proxy_mapper.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/proxy_mapper_registry.cc" role="src" />
-    <file baseinstalldir="/" name="src/core/ext/filters/client_channel/request_routing.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver_registry.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolver_result_parsing.cc" role="src" />
+    <file baseinstalldir="/" name="src/core/ext/filters/client_channel/resolving_lb_policy.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/retry_throttle.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/server_address.cc" role="src" />
     <file baseinstalldir="/" name="src/core/ext/filters/client_channel/subchannel.cc" role="src" />

setup.py

@@ -159,7 +159,7 @@ if EXTRA_ENV_COMPILE_ARGS is None:
   elif "linux" in sys.platform:
     EXTRA_ENV_COMPILE_ARGS += ' -std=gnu99 -fvisibility=hidden -fno-wrapv -fno-exceptions'
   elif "darwin" in sys.platform:
-    EXTRA_ENV_COMPILE_ARGS += ' -fvisibility=hidden -fno-wrapv -fno-exceptions'
+    EXTRA_ENV_COMPILE_ARGS += ' -stdlib=libc++ -fvisibility=hidden -fno-wrapv -fno-exceptions'
 EXTRA_ENV_COMPILE_ARGS += ' -DPB_FIELD_32BIT'
 
 if EXTRA_ENV_LINK_ARGS is None:
@@ -265,7 +265,7 @@ def cython_extensions_and_necessity():
                   for name in CYTHON_EXTENSION_MODULE_NAMES]
   config = os.environ.get('CONFIG', 'opt')
   prefix = 'libs/' + config + '/'
-  if "darwin" in sys.platform or USE_PREBUILT_GRPC_CORE:
+  if USE_PREBUILT_GRPC_CORE:
     extra_objects = [prefix + 'libares.a',
                      prefix + 'libboringssl.a',
                      prefix + 'libgpr.a',

src/compiler/protobuf_plugin.h

@@ -108,11 +108,11 @@ class ProtoBufService : public grpc_generator::Service {
 
   grpc::string name() const { return service_->name(); }
 
-  int method_count() const { return service_->method_count(); };
+  int method_count() const { return service_->method_count(); }
   std::unique_ptr<const grpc_generator::Method> method(int i) const {
     return std::unique_ptr<const grpc_generator::Method>(
         new ProtoBufMethod(service_->method(i)));
-  };
+  }
 
   grpc::string GetLeadingComments(const grpc::string prefix) const {
     return GetCommentsHelper(service_, true, prefix);
@@ -166,7 +166,7 @@ class ProtoBufFile : public grpc_generator::File {
 
   grpc::string additional_headers() const { return ""; }
 
-  int service_count() const { return file_->service_count(); };
+  int service_count() const { return file_->service_count(); }
   std::unique_ptr<const grpc_generator::Service> service(int i) const {
     return std::unique_ptr<const grpc_generator::Service>(
         new ProtoBufService(file_->service(i)));

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

@@ -32,12 +32,14 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/ext/filters/client_channel/backup_poller.h"
+#include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/filters/client_channel/local_subchannel_pool.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
-#include "src/core/ext/filters/client_channel/request_routing.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
+#include "src/core/ext/filters/client_channel/resolving_lb_policy.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/filters/deadline/deadline_filter.h"
@@ -68,6 +70,8 @@ using grpc_core::internal::ClientChannelMethodParamsTable;
 using grpc_core::internal::ProcessedResolverResult;
 using grpc_core::internal::ServerRetryThrottleData;
 
+using grpc_core::LoadBalancingPolicy;
+
 /* Client channel implementation */
 
 // By default, we buffer 256 KiB per RPC for retries.
@@ -86,44 +90,170 @@ grpc_core::TraceFlag grpc_client_channel_trace(false, "client_channel");
 
 struct external_connectivity_watcher;
 
-typedef struct client_channel_channel_data {
-  grpc_core::ManualConstructor<grpc_core::RequestRouter> request_router;
+struct QueuedPick {
+  LoadBalancingPolicy::PickState pick;
+  grpc_call_element* elem;
+  QueuedPick* next = nullptr;
+};
 
+typedef struct client_channel_channel_data {
   bool deadline_checking_enabled;
   bool enable_retries;
   size_t per_rpc_retry_buffer_size;
 
   /** combiner protecting all variables below in this data structure */
   grpc_combiner* combiner;
-  /** retry throttle data */
-  grpc_core::RefCountedPtr<ServerRetryThrottleData> retry_throttle_data;
-  /** maps method names to method_parameters structs */
-  grpc_core::RefCountedPtr<ClientChannelMethodParamsTable> method_params_table;
   /** owning stack */
   grpc_channel_stack* owning_stack;
   /** interested parties (owned) */
   grpc_pollset_set* interested_parties;
-
-  /* external_connectivity_watcher_list head is guarded by its own mutex, since
-   * counts need to be grabbed immediately without polling on a cq */
-  gpr_mu external_connectivity_watcher_list_mu;
-  struct external_connectivity_watcher* external_connectivity_watcher_list_head;
+  // Client channel factory.  Holds a ref.
+  grpc_client_channel_factory* client_channel_factory;
+  // Subchannel pool.
+  grpc_core::RefCountedPtr<grpc_core::SubchannelPoolInterface> subchannel_pool;
+
+  grpc_core::channelz::ClientChannelNode* channelz_node;
+
+  // Resolving LB policy.
+  grpc_core::OrphanablePtr<LoadBalancingPolicy> resolving_lb_policy;
+  // Subchannel picker from LB policy.
+  grpc_core::UniquePtr<LoadBalancingPolicy::SubchannelPicker> picker;
+  // Linked list of queued picks.
+  QueuedPick* queued_picks;
+
+  bool have_service_config;
+  /** retry throttle data from service config */
+  grpc_core::RefCountedPtr<ServerRetryThrottleData> retry_throttle_data;
+  /** per-method service config data */
+  grpc_core::RefCountedPtr<ClientChannelMethodParamsTable> method_params_table;
 
   /* the following properties are guarded by a mutex since APIs require them
      to be instantaneously available */
   gpr_mu info_mu;
   grpc_core::UniquePtr<char> info_lb_policy_name;
-  /** service config in JSON form */
   grpc_core::UniquePtr<char> info_service_config_json;
+
+  grpc_connectivity_state_tracker state_tracker;
+  grpc_error* disconnect_error;
+
+  /* external_connectivity_watcher_list head is guarded by its own mutex, since
+   * counts need to be grabbed immediately without polling on a cq */
+  gpr_mu external_connectivity_watcher_list_mu;
+  struct external_connectivity_watcher* external_connectivity_watcher_list_head;
 } channel_data;
 
-// Synchronous callback from chand->request_router to process a resolver
+// Forward declarations.
+static void start_pick_locked(void* arg, grpc_error* ignored);
+static void maybe_apply_service_config_to_call_locked(grpc_call_element* elem);
+
+static const char* get_channel_connectivity_state_change_string(
+    grpc_connectivity_state state) {
+  switch (state) {
+    case GRPC_CHANNEL_IDLE:
+      return "Channel state change to IDLE";
+    case GRPC_CHANNEL_CONNECTING:
+      return "Channel state change to CONNECTING";
+    case GRPC_CHANNEL_READY:
+      return "Channel state change to READY";
+    case GRPC_CHANNEL_TRANSIENT_FAILURE:
+      return "Channel state change to TRANSIENT_FAILURE";
+    case GRPC_CHANNEL_SHUTDOWN:
+      return "Channel state change to SHUTDOWN";
+  }
+  GPR_UNREACHABLE_CODE(return "UNKNOWN");
+}
+
+static void set_connectivity_state_and_picker_locked(
+    channel_data* chand, grpc_connectivity_state state, grpc_error* state_error,
+    const char* reason,
+    grpc_core::UniquePtr<LoadBalancingPolicy::SubchannelPicker> picker) {
+  // Update connectivity state.
+  grpc_connectivity_state_set(&chand->state_tracker, state, state_error,
+                              reason);
+  if (chand->channelz_node != nullptr) {
+    chand->channelz_node->AddTraceEvent(
+        grpc_core::channelz::ChannelTrace::Severity::Info,
+        grpc_slice_from_static_string(
+            get_channel_connectivity_state_change_string(state)));
+  }
+  // Update picker.
+  chand->picker = std::move(picker);
+  // Re-process queued picks.
+  for (QueuedPick* pick = chand->queued_picks; pick != nullptr;
+       pick = pick->next) {
+    start_pick_locked(pick->elem, GRPC_ERROR_NONE);
+  }
+}
+
+namespace grpc_core {
+namespace {
+
+class ClientChannelControlHelper
+    : public LoadBalancingPolicy::ChannelControlHelper {
+ public:
+  explicit ClientChannelControlHelper(channel_data* chand) : chand_(chand) {
+    GRPC_CHANNEL_STACK_REF(chand_->owning_stack, "ClientChannelControlHelper");
+  }
+
+  ~ClientChannelControlHelper() override {
+    GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack,
+                             "ClientChannelControlHelper");
+  }
+
+  Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
+    grpc_arg arg = SubchannelPoolInterface::CreateChannelArg(
+        chand_->subchannel_pool.get());
+    grpc_channel_args* new_args =
+        grpc_channel_args_copy_and_add(&args, &arg, 1);
+    Subchannel* subchannel = grpc_client_channel_factory_create_subchannel(
+        chand_->client_channel_factory, new_args);
+    grpc_channel_args_destroy(new_args);
+    return subchannel;
+  }
+
+  grpc_channel* CreateChannel(const char* target, grpc_client_channel_type type,
+                              const grpc_channel_args& args) override {
+    return grpc_client_channel_factory_create_channel(
+        chand_->client_channel_factory, target, type, &args);
+  }
+
+  void UpdateState(
+      grpc_connectivity_state state, grpc_error* state_error,
+      UniquePtr<LoadBalancingPolicy::SubchannelPicker> picker) override {
+    if (grpc_client_channel_trace.enabled()) {
+      const char* extra = chand_->disconnect_error == GRPC_ERROR_NONE
+                              ? ""
+                              : " (ignoring -- channel shutting down)";
+      gpr_log(GPR_INFO, "chand=%p: update: state=%s error=%s picker=%p%s",
+              chand_, grpc_connectivity_state_name(state),
+              grpc_error_string(state_error), picker.get(), extra);
+    }
+    // Do update only if not shutting down.
+    if (chand_->disconnect_error == GRPC_ERROR_NONE) {
+      set_connectivity_state_and_picker_locked(chand_, state, state_error,
+                                               "helper", std::move(picker));
+    } else {
+      GRPC_ERROR_UNREF(state_error);
+    }
+  }
+
+  // No-op -- we should never get this from ResolvingLoadBalancingPolicy.
+  void RequestReresolution() override {}
+
+ private:
+  channel_data* chand_;
+};
+
+}  // namespace
+}  // namespace grpc_core
+
+// Synchronous callback from chand->resolving_lb_policy to process a resolver
 // result update.
-static bool process_resolver_result_locked(void* arg,
-                                           const grpc_channel_args& args,
-                                           const char** lb_policy_name,
-                                           grpc_json** lb_policy_config) {
+static bool process_resolver_result_locked(
+    void* arg, const grpc_channel_args& args, const char** lb_policy_name,
+    grpc_core::RefCountedPtr<LoadBalancingPolicy::Config>* lb_policy_config) {
   channel_data* chand = static_cast<channel_data*>(arg);
+  chand->have_service_config = true;
   ProcessedResolverResult resolver_result(args, chand->enable_retries);
   grpc_core::UniquePtr<char> service_config_json =
       resolver_result.service_config_json();
@@ -148,9 +278,38 @@ static bool process_resolver_result_locked(void* arg,
   // Return results.
   *lb_policy_name = chand->info_lb_policy_name.get();
   *lb_policy_config = resolver_result.lb_policy_config();
+  // Apply service config to queued picks.
+  for (QueuedPick* pick = chand->queued_picks; pick != nullptr;
+       pick = pick->next) {
+    maybe_apply_service_config_to_call_locked(pick->elem);
+  }
   return service_config_changed;
 }
 
+static grpc_error* do_ping_locked(channel_data* chand, grpc_transport_op* op) {
+  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_connectivity_state state =
+      grpc_connectivity_state_get(&chand->state_tracker, &error);
+  if (state != GRPC_CHANNEL_READY) {
+    grpc_error* new_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "channel not connected", &error, 1);
+    GRPC_ERROR_UNREF(error);
+    return new_error;
+  }
+  LoadBalancingPolicy::PickState pick;
+  chand->picker->Pick(&pick, &error);
+  if (pick.connected_subchannel != nullptr) {
+    pick.connected_subchannel->Ping(op->send_ping.on_initiate,
+                                    op->send_ping.on_ack);
+  } else {
+    if (error == GRPC_ERROR_NONE) {
+      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "LB policy dropped call on ping");
+    }
+  }
+  return error;
+}
+
 static void start_transport_op_locked(void* arg, grpc_error* error_ignored) {
   grpc_transport_op* op = static_cast<grpc_transport_op*>(arg);
   grpc_channel_element* elem =
@@ -158,47 +317,40 @@ static void start_transport_op_locked(void* arg, grpc_error* error_ignored) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
 
   if (op->on_connectivity_state_change != nullptr) {
-    chand->request_router->NotifyOnConnectivityStateChange(
-        op->connectivity_state, op->on_connectivity_state_change);
+    grpc_connectivity_state_notify_on_state_change(
+        &chand->state_tracker, op->connectivity_state,
+        op->on_connectivity_state_change);
     op->on_connectivity_state_change = nullptr;
     op->connectivity_state = nullptr;
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
-    if (chand->request_router->lb_policy() == nullptr) {
-      grpc_error* error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Ping with no load balancing");
+    grpc_error* error = do_ping_locked(chand, op);
+    if (error != GRPC_ERROR_NONE) {
       GRPC_CLOSURE_SCHED(op->send_ping.on_initiate, GRPC_ERROR_REF(error));
       GRPC_CLOSURE_SCHED(op->send_ping.on_ack, error);
-    } else {
-      grpc_error* error = GRPC_ERROR_NONE;
-      grpc_core::LoadBalancingPolicy::PickState pick_state;
-      // Pick must return synchronously, because pick_state.on_complete is null.
-      GPR_ASSERT(
-          chand->request_router->lb_policy()->PickLocked(&pick_state, &error));
-      if (pick_state.connected_subchannel != nullptr) {
-        pick_state.connected_subchannel->Ping(op->send_ping.on_initiate,
-                                              op->send_ping.on_ack);
-      } else {
-        if (error == GRPC_ERROR_NONE) {
-          error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "LB policy dropped call on ping");
-        }
-        GRPC_CLOSURE_SCHED(op->send_ping.on_initiate, GRPC_ERROR_REF(error));
-        GRPC_CLOSURE_SCHED(op->send_ping.on_ack, error);
-      }
-      op->bind_pollset = nullptr;
     }
+    op->bind_pollset = nullptr;
     op->send_ping.on_initiate = nullptr;
     op->send_ping.on_ack = nullptr;
   }
 
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    chand->request_router->ShutdownLocked(op->disconnect_with_error);
+  if (op->reset_connect_backoff) {
+    chand->resolving_lb_policy->ResetBackoffLocked();
   }
 
-  if (op->reset_connect_backoff) {
-    chand->request_router->ResetConnectionBackoffLocked();
+  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+    chand->disconnect_error = op->disconnect_with_error;
+    grpc_pollset_set_del_pollset_set(
+        chand->resolving_lb_policy->interested_parties(),
+        chand->interested_parties);
+    chand->resolving_lb_policy.reset();
+    set_connectivity_state_and_picker_locked(
+        chand, GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(op->disconnect_with_error),
+        "shutdown from API",
+        grpc_core::UniquePtr<LoadBalancingPolicy::SubchannelPicker>(
+            grpc_core::New<LoadBalancingPolicy::TransientFailurePicker>(
+                GRPC_ERROR_REF(op->disconnect_with_error))));
   }
 
   GRPC_CHANNEL_STACK_UNREF(chand->owning_stack, "start_transport_op");
@@ -244,6 +396,9 @@ static grpc_error* cc_init_channel_elem(grpc_channel_element* elem,
   GPR_ASSERT(elem->filter == &grpc_client_channel_filter);
   // Initialize data members.
   chand->combiner = grpc_combiner_create();
+  grpc_connectivity_state_init(&chand->state_tracker, GRPC_CHANNEL_IDLE,
+                               "client_channel");
+  chand->disconnect_error = GRPC_ERROR_NONE;
   gpr_mu_init(&chand->info_mu);
   gpr_mu_init(&chand->external_connectivity_watcher_list_mu);
 
@@ -275,8 +430,9 @@ static grpc_error* cc_init_channel_elem(grpc_channel_element* elem,
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "client channel factory arg must be a pointer");
   }
-  grpc_client_channel_factory* client_channel_factory =
+  chand->client_channel_factory =
       static_cast<grpc_client_channel_factory*>(arg->value.pointer.p);
+  grpc_client_channel_factory_ref(chand->client_channel_factory);
   // Get server name to resolve, using proxy mapper if needed.
   arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVER_URI);
   if (arg == nullptr) {
@@ -291,26 +447,71 @@ static grpc_error* cc_init_channel_elem(grpc_channel_element* elem,
   grpc_channel_args* new_args = nullptr;
   grpc_proxy_mappers_map_name(arg->value.string, args->channel_args,
                               &proxy_name, &new_args);
-  // Instantiate request router.
-  grpc_client_channel_factory_ref(client_channel_factory);
+  grpc_core::UniquePtr<char> target_uri(
+      proxy_name != nullptr ? proxy_name : gpr_strdup(arg->value.string));
+  // Instantiate subchannel pool.
+  arg = grpc_channel_args_find(args->channel_args,
+                               GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL);
+  if (grpc_channel_arg_get_bool(arg, false)) {
+    chand->subchannel_pool =
+        grpc_core::MakeRefCounted<grpc_core::LocalSubchannelPool>();
+  } else {
+    chand->subchannel_pool = grpc_core::GlobalSubchannelPool::instance();
+  }
+  // Instantiate resolving LB policy.
+  LoadBalancingPolicy::Args lb_args;
+  lb_args.combiner = chand->combiner;
+  lb_args.channel_control_helper =
+      grpc_core::UniquePtr<LoadBalancingPolicy::ChannelControlHelper>(
+          grpc_core::New<grpc_core::ClientChannelControlHelper>(chand));
+  lb_args.args = new_args != nullptr ? new_args : args->channel_args;
   grpc_error* error = GRPC_ERROR_NONE;
-  chand->request_router.Init(
-      chand->owning_stack, chand->combiner, client_channel_factory,
-      chand->interested_parties, &grpc_client_channel_trace,
-      process_resolver_result_locked, chand,
-      proxy_name != nullptr ? proxy_name : arg->value.string /* target_uri */,
-      new_args != nullptr ? new_args : args->channel_args, &error);
-  gpr_free(proxy_name);
+  chand->resolving_lb_policy.reset(
+      grpc_core::New<grpc_core::ResolvingLoadBalancingPolicy>(
+          std::move(lb_args), &grpc_client_channel_trace, std::move(target_uri),
+          process_resolver_result_locked, chand, &error));
   grpc_channel_args_destroy(new_args);
+  if (error != GRPC_ERROR_NONE) {
+    // Orphan the resolving LB policy and flush the exec_ctx to ensure
+    // that it finishes shutting down.  This ensures that if we are
+    // failing, we destroy the ClientChannelControlHelper (and thus
+    // unref the channel stack) before we return.
+    // TODO(roth): This is not a complete solution, because it only
+    // catches the case where channel stack initialization fails in this
+    // particular filter.  If there is a failure in a different filter, we
+    // will leave a dangling ref here, which can cause a crash.  Fortunately,
+    // in practice, there are no other filters that can cause failures in
+    // channel stack initialization, so this works for now.
+    chand->resolving_lb_policy.reset();
+    grpc_core::ExecCtx::Get()->Flush();
+  } else {
+    grpc_pollset_set_add_pollset_set(
+        chand->resolving_lb_policy->interested_parties(),
+        chand->interested_parties);
+    if (grpc_client_channel_trace.enabled()) {
+      gpr_log(GPR_INFO, "chand=%p: created resolving_lb_policy=%p", chand,
+              chand->resolving_lb_policy.get());
+    }
+  }
   return error;
 }
 
 /* Destructor for channel_data */
 static void cc_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  chand->request_router.Destroy();
+  if (chand->resolving_lb_policy != nullptr) {
+    grpc_pollset_set_del_pollset_set(
+        chand->resolving_lb_policy->interested_parties(),
+        chand->interested_parties);
+    chand->resolving_lb_policy.reset();
+  }
   // TODO(roth): Once we convert the filter API to C++, there will no
   // longer be any need to explicitly reset these smart pointer data members.
+  chand->picker.reset();
+  chand->subchannel_pool.reset();
+  if (chand->client_channel_factory != nullptr) {
+    grpc_client_channel_factory_unref(chand->client_channel_factory);
+  }
   chand->info_lb_policy_name.reset();
   chand->info_service_config_json.reset();
   chand->retry_throttle_data.reset();
@@ -318,6 +519,8 @@ static void cc_destroy_channel_elem(grpc_channel_element* elem) {
   grpc_client_channel_stop_backup_polling(chand->interested_parties);
   grpc_pollset_set_destroy(chand->interested_parties);
   GRPC_COMBINER_UNREF(chand->combiner, "client_channel");
+  GRPC_ERROR_UNREF(chand->disconnect_error);
+  grpc_connectivity_state_destroy(&chand->state_tracker);
   gpr_mu_destroy(&chand->info_mu);
   gpr_mu_destroy(&chand->external_connectivity_watcher_list_mu);
 }
@@ -371,6 +574,12 @@ static void cc_destroy_channel_elem(grpc_channel_element* elem) {
 //   (census filter is on top of this one)
 // - add census stats for retries
 
+namespace grpc_core {
+namespace {
+class QueuedPickCanceller;
+}  // namespace
+}  // namespace grpc_core
+
 namespace {
 
 struct call_data;
@@ -509,8 +718,11 @@ struct call_data {
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches); ++i) {
       GPR_ASSERT(pending_batches[i].batch == nullptr);
     }
-    if (have_request) {
-      request.Destroy();
+    for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
+      if (pick.pick.subchannel_call_context[i].destroy != nullptr) {
+        pick.pick.subchannel_call_context[i].destroy(
+            pick.pick.subchannel_call_context[i].value);
+      }
     }
   }
 
@@ -537,8 +749,10 @@ struct call_data {
   // Set when we get a cancel_stream op.
   grpc_error* cancel_error = GRPC_ERROR_NONE;
 
-  grpc_core::ManualConstructor<grpc_core::RequestRouter::Request> request;
-  bool have_request = false;
+  QueuedPick pick;
+  bool pick_queued = false;
+  bool service_config_applied = false;
+  grpc_core::QueuedPickCanceller* pick_canceller = nullptr;
   grpc_closure pick_closure;
 
   grpc_polling_entity* pollent = nullptr;
@@ -600,7 +814,7 @@ static void retry_commit(grpc_call_element* elem,
 static void start_internal_recv_trailing_metadata(grpc_call_element* elem);
 static void on_complete(void* arg, grpc_error* error);
 static void start_retriable_subchannel_batches(void* arg, grpc_error* ignored);
-static void start_pick_locked(void* arg, grpc_error* ignored);
+static void remove_call_from_queued_picks_locked(grpc_call_element* elem);
 
 //
 // send op data caching
@@ -728,7 +942,7 @@ static void free_cached_send_op_data_for_completed_batch(
 //
 
 void maybe_inject_recv_trailing_metadata_ready_for_lb(
-    const grpc_core::LoadBalancingPolicy::PickState& pick,
+    const LoadBalancingPolicy::PickState& pick,
     grpc_transport_stream_op_batch* batch) {
   if (pick.recv_trailing_metadata_ready != nullptr) {
     *pick.original_recv_trailing_metadata_ready =
@@ -846,10 +1060,25 @@ static void fail_pending_batch_in_call_combiner(void* arg, grpc_error* error) {
 }
 
 // This is called via the call combiner, so access to calld is synchronized.
-// If yield_call_combiner is true, assumes responsibility for yielding
-// the call combiner.
-static void pending_batches_fail(grpc_call_element* elem, grpc_error* error,
-                                 bool yield_call_combiner) {
+// If yield_call_combiner_predicate returns true, assumes responsibility for
+// yielding the call combiner.
+typedef bool (*YieldCallCombinerPredicate)(
+    const grpc_core::CallCombinerClosureList& closures);
+static bool yield_call_combiner(
+    const grpc_core::CallCombinerClosureList& closures) {
+  return true;
+}
+static bool no_yield_call_combiner(
+    const grpc_core::CallCombinerClosureList& closures) {
+  return false;
+}
+static bool yield_call_combiner_if_pending_batches_found(
+    const grpc_core::CallCombinerClosureList& closures) {
+  return closures.size() > 0;
+}
+static void pending_batches_fail(
+    grpc_call_element* elem, grpc_error* error,
+    YieldCallCombinerPredicate yield_call_combiner_predicate) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (grpc_client_channel_trace.enabled()) {
@@ -866,9 +1095,9 @@ static void pending_batches_fail(grpc_call_element* elem, grpc_error* error,
     pending_batch* pending = &calld->pending_batches[i];
     grpc_transport_stream_op_batch* batch = pending->batch;
     if (batch != nullptr) {
-      if (batch->recv_trailing_metadata && calld->have_request) {
-        maybe_inject_recv_trailing_metadata_ready_for_lb(
-            *calld->request->pick(), batch);
+      if (batch->recv_trailing_metadata) {
+        maybe_inject_recv_trailing_metadata_ready_for_lb(calld->pick.pick,
+                                                         batch);
       }
       batch->handler_private.extra_arg = calld;
       GRPC_CLOSURE_INIT(&batch->handler_private.closure,
@@ -879,7 +1108,7 @@ static void pending_batches_fail(grpc_call_element* elem, grpc_error* error,
       pending_batch_clear(calld, pending);
     }
   }
-  if (yield_call_combiner) {
+  if (yield_call_combiner_predicate(closures)) {
     closures.RunClosures(calld->call_combiner);
   } else {
     closures.RunClosuresWithoutYielding(calld->call_combiner);
@@ -923,8 +1152,8 @@ static void pending_batches_resume(grpc_call_element* elem) {
     grpc_transport_stream_op_batch* batch = pending->batch;
     if (batch != nullptr) {
       if (batch->recv_trailing_metadata) {
-        maybe_inject_recv_trailing_metadata_ready_for_lb(
-            *calld->request->pick(), batch);
+        maybe_inject_recv_trailing_metadata_ready_for_lb(calld->pick.pick,
+                                                         batch);
       }
       batch->handler_private.extra_arg = calld->subchannel_call.get();
       GRPC_CLOSURE_INIT(&batch->handler_private.closure,
@@ -1015,11 +1244,9 @@ static void do_retry(grpc_call_element* elem,
   const ClientChannelMethodParams::RetryPolicy* retry_policy =
       calld->method_params->retry_policy();
   GPR_ASSERT(retry_policy != nullptr);
+  // Reset subchannel call and connected subchannel.
   calld->subchannel_call.reset();
-  if (calld->have_request) {
-    calld->have_request = false;
-    calld->request.Destroy();
-  }
+  calld->pick.pick.connected_subchannel.reset();
   // Compute backoff delay.
   grpc_millis next_attempt_time;
   if (server_pushback_ms >= 0) {
@@ -1938,7 +2165,7 @@ static void add_retriable_recv_trailing_metadata_op(
   batch_data->batch.payload->recv_trailing_metadata
       .recv_trailing_metadata_ready =
       &retry_state->recv_trailing_metadata_ready;
-  maybe_inject_recv_trailing_metadata_ready_for_lb(*calld->request->pick(),
+  maybe_inject_recv_trailing_metadata_ready_for_lb(calld->pick.pick,
                                                    &batch_data->batch);
 }
 
@@ -2207,41 +2434,38 @@ static void start_retriable_subchannel_batches(void* arg, grpc_error* ignored) {
 // LB pick
 //
 
-static void create_subchannel_call(grpc_call_element* elem, grpc_error* error) {
+static void create_subchannel_call(grpc_call_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   const size_t parent_data_size =
       calld->enable_retries ? sizeof(subchannel_call_retry_state) : 0;
   const grpc_core::ConnectedSubchannel::CallArgs call_args = {
-      calld->pollent,                                   // pollent
-      calld->path,                                      // path
-      calld->call_start_time,                           // start_time
-      calld->deadline,                                  // deadline
-      calld->arena,                                     // arena
-      calld->request->pick()->subchannel_call_context,  // context
-      calld->call_combiner,                             // call_combiner
-      parent_data_size                                  // parent_data_size
+      calld->pollent,                            // pollent
+      calld->path,                               // path
+      calld->call_start_time,                    // start_time
+      calld->deadline,                           // deadline
+      calld->arena,                              // arena
+      calld->pick.pick.subchannel_call_context,  // context
+      calld->call_combiner,                      // call_combiner
+      parent_data_size                           // parent_data_size
   };
-  grpc_error* new_error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   calld->subchannel_call =
-      calld->request->pick()->connected_subchannel->CreateCall(call_args,
-                                                               &new_error);
+      calld->pick.pick.connected_subchannel->CreateCall(call_args, &error);
   if (grpc_client_channel_trace.enabled()) {
     gpr_log(GPR_INFO, "chand=%p calld=%p: create subchannel_call=%p: error=%s",
             chand, calld, calld->subchannel_call.get(),
-            grpc_error_string(new_error));
+            grpc_error_string(error));
   }
-  if (GPR_UNLIKELY(new_error != GRPC_ERROR_NONE)) {
-    new_error = grpc_error_add_child(new_error, error);
-    pending_batches_fail(elem, new_error, true /* yield_call_combiner */);
+  if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
+    pending_batches_fail(elem, error, yield_call_combiner);
   } else {
     if (parent_data_size > 0) {
-      new (calld->subchannel_call->GetParentData()) subchannel_call_retry_state(
-          calld->request->pick()->subchannel_call_context);
+      new (calld->subchannel_call->GetParentData())
+          subchannel_call_retry_state(calld->pick.pick.subchannel_call_context);
     }
     pending_batches_resume(elem);
   }
-  GRPC_ERROR_UNREF(error);
 }
 
 // Invoked when a pick is completed, on both success or failure.
@@ -2249,54 +2473,106 @@ static void pick_done(void* arg, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (GPR_UNLIKELY(calld->request->pick()->connected_subchannel == nullptr)) {
-    // Failed to create subchannel.
-    // If there was no error, this is an LB policy drop, in which case
-    // we return an error; otherwise, we may retry.
-    grpc_status_code status = GRPC_STATUS_OK;
-    grpc_error_get_status(error, calld->deadline, &status, nullptr, nullptr,
-                          nullptr);
-    if (error == GRPC_ERROR_NONE || !calld->enable_retries ||
-        !maybe_retry(elem, nullptr /* batch_data */, status,
-                     nullptr /* server_pushback_md */)) {
-      grpc_error* new_error =
-          error == GRPC_ERROR_NONE
-              ? GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                    "Call dropped by load balancing policy")
-              : GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                    "Failed to create subchannel", &error, 1);
+  if (error != GRPC_ERROR_NONE) {
+    if (grpc_client_channel_trace.enabled()) {
+      gpr_log(GPR_INFO,
+              "chand=%p calld=%p: failed to pick subchannel: error=%s", chand,
+              calld, grpc_error_string(error));
+    }
+    pending_batches_fail(elem, GRPC_ERROR_REF(error), yield_call_combiner);
+    return;
+  }
+  create_subchannel_call(elem);
+}
+
+namespace grpc_core {
+namespace {
+
+// A class to handle the call combiner cancellation callback for a
+// queued pick.
+class QueuedPickCanceller {
+ public:
+  explicit QueuedPickCanceller(grpc_call_element* elem) : elem_(elem) {
+    auto* calld = static_cast<call_data*>(elem->call_data);
+    auto* chand = static_cast<channel_data*>(elem->channel_data);
+    GRPC_CALL_STACK_REF(calld->owning_call, "QueuedPickCanceller");
+    GRPC_CLOSURE_INIT(&closure_, &CancelLocked, this,
+                      grpc_combiner_scheduler(chand->combiner));
+    grpc_call_combiner_set_notify_on_cancel(calld->call_combiner, &closure_);
+  }
+
+ private:
+  static void CancelLocked(void* arg, grpc_error* error) {
+    auto* self = static_cast<QueuedPickCanceller*>(arg);
+    auto* chand = static_cast<channel_data*>(self->elem_->channel_data);
+    auto* calld = static_cast<call_data*>(self->elem_->call_data);
+    if (grpc_client_channel_trace.enabled()) {
+      gpr_log(GPR_INFO,
+              "chand=%p calld=%p: cancelling queued pick: "
+              "error=%s self=%p calld->pick_canceller=%p",
+              chand, calld, grpc_error_string(error), self,
+              calld->pick_canceller);
+    }
+    if (calld->pick_canceller == self && error != GRPC_ERROR_NONE) {
+      // Remove pick from list of queued picks.
+      remove_call_from_queued_picks_locked(self->elem_);
+      // Fail pending batches on the call.
+      pending_batches_fail(self->elem_, GRPC_ERROR_REF(error),
+                           yield_call_combiner_if_pending_batches_found);
+    }
+    GRPC_CALL_STACK_UNREF(calld->owning_call, "QueuedPickCanceller");
+    Delete(self);
+  }
+
+  grpc_call_element* elem_;
+  grpc_closure closure_;
+};
+
+}  // namespace
+}  // namespace grpc_core
+
+// Removes the call from the channel's list of queued picks.
+static void remove_call_from_queued_picks_locked(grpc_call_element* elem) {
+  auto* chand = static_cast<channel_data*>(elem->channel_data);
+  auto* calld = static_cast<call_data*>(elem->call_data);
+  for (QueuedPick** pick = &chand->queued_picks; *pick != nullptr;
+       pick = &(*pick)->next) {
+    if (*pick == &calld->pick) {
       if (grpc_client_channel_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "chand=%p calld=%p: failed to create subchannel: error=%s",
-                chand, calld, grpc_error_string(new_error));
+        gpr_log(GPR_INFO, "chand=%p calld=%p: removing from queued picks list",
+                chand, calld);
       }
-      pending_batches_fail(elem, new_error, true /* yield_call_combiner */);
+      calld->pick_queued = false;
+      *pick = calld->pick.next;
+      // Remove call's pollent from channel's interested_parties.
+      grpc_polling_entity_del_from_pollset_set(calld->pollent,
+                                               chand->interested_parties);
+      // Lame the call combiner canceller.
+      calld->pick_canceller = nullptr;
+      break;
     }
-  } else {
-    /* Create call on subchannel. */
-    create_subchannel_call(elem, GRPC_ERROR_REF(error));
   }
 }
 
-// If the channel is in TRANSIENT_FAILURE and the call is not
-// wait_for_ready=true, fails the call and returns true.
-static bool fail_call_if_in_transient_failure(grpc_call_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_transport_stream_op_batch* batch = calld->pending_batches[0].batch;
-  if (chand->request_router->GetConnectivityState() ==
-          GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      (batch->payload->send_initial_metadata.send_initial_metadata_flags &
-       GRPC_INITIAL_METADATA_WAIT_FOR_READY) == 0) {
-    pending_batches_fail(
-        elem,
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                               "channel is in state TRANSIENT_FAILURE"),
-                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
-        true /* yield_call_combiner */);
-    return true;
+// Adds the call to the channel's list of queued picks.
+static void add_call_to_queued_picks_locked(grpc_call_element* elem) {
+  auto* chand = static_cast<channel_data*>(elem->channel_data);
+  auto* calld = static_cast<call_data*>(elem->call_data);
+  if (grpc_client_channel_trace.enabled()) {
+    gpr_log(GPR_INFO, "chand=%p calld=%p: adding to queued picks list", chand,
+            calld);
   }
-  return false;
+  calld->pick_queued = true;
+  // Add call to queued picks list.
+  calld->pick.elem = elem;
+  calld->pick.next = chand->queued_picks;
+  chand->queued_picks = &calld->pick;
+  // Add call's pollent to channel's interested_parties, so that I/O
+  // can be done under the call's CQ.
+  grpc_polling_entity_add_to_pollset_set(calld->pollent,
+                                         chand->interested_parties);
+  // Register call combiner cancellation callback.
+  calld->pick_canceller = grpc_core::New<grpc_core::QueuedPickCanceller>(elem);
 }
 
 // Applies service config to the call.  Must be invoked once we know
@@ -2356,36 +2632,37 @@ static void apply_service_config_to_call_locked(grpc_call_element* elem) {
 }
 
 // Invoked once resolver results are available.
-static bool maybe_apply_service_config_to_call_locked(void* arg) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
+static void maybe_apply_service_config_to_call_locked(grpc_call_element* elem) {
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  // Only get service config data on the first attempt.
-  if (GPR_LIKELY(calld->num_attempts_completed == 0)) {
+  // Apply service config data to the call only once, and only if the
+  // channel has the data available.
+  if (GPR_LIKELY(chand->have_service_config &&
+                 !calld->service_config_applied)) {
+    calld->service_config_applied = true;
     apply_service_config_to_call_locked(elem);
-    // Check this after applying service config, since it may have
-    // affected the call's wait_for_ready value.
-    if (fail_call_if_in_transient_failure(elem)) return false;
   }
-  return true;
 }
 
-static void start_pick_locked(void* arg, grpc_error* ignored) {
+static const char* pick_result_name(
+    LoadBalancingPolicy::SubchannelPicker::PickResult result) {
+  switch (result) {
+    case LoadBalancingPolicy::SubchannelPicker::PICK_COMPLETE:
+      return "COMPLETE";
+    case LoadBalancingPolicy::SubchannelPicker::PICK_QUEUE:
+      return "QUEUE";
+    case LoadBalancingPolicy::SubchannelPicker::PICK_TRANSIENT_FAILURE:
+      return "TRANSIENT_FAILURE";
+  }
+  GPR_UNREACHABLE_CODE(return "UNKNOWN");
+}
+
+static void start_pick_locked(void* arg, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(!calld->have_request);
+  GPR_ASSERT(calld->pick.pick.connected_subchannel == nullptr);
   GPR_ASSERT(calld->subchannel_call == nullptr);
-  // Normally, we want to do this check until after we've processed the
-  // service config, so that we can honor the wait_for_ready setting in
-  // the service config.  However, if the channel is in TRANSIENT_FAILURE
-  // and we don't have an LB policy at this point, that means that the
-  // resolver has returned a failure, so we're not going to get a service
-  // config right away.  In that case, we fail the call now based on the
-  // wait_for_ready value passed in from the application.
-  if (chand->request_router->lb_policy() == nullptr &&
-      fail_call_if_in_transient_failure(elem)) {
-    return;
-  }
   // If this is a retry, use the send_initial_metadata payload that
   // we've cached; otherwise, use the pending batch.  The
   // send_initial_metadata batch will be the first pending batch in the
@@ -2396,25 +2673,78 @@ static void start_pick_locked(void* arg, grpc_error* ignored) {
   // allocate the subchannel batch earlier so that we can give the
   // subchannel's copy of the metadata batch (which is copied for each
   // attempt) to the LB policy instead the one from the parent channel.
-  grpc_metadata_batch* initial_metadata =
+  calld->pick.pick.initial_metadata =
       calld->seen_send_initial_metadata
           ? &calld->send_initial_metadata
           : calld->pending_batches[0]
                 .batch->payload->send_initial_metadata.send_initial_metadata;
-  uint32_t* initial_metadata_flags =
+  uint32_t* send_initial_metadata_flags =
       calld->seen_send_initial_metadata
           ? &calld->send_initial_metadata_flags
           : &calld->pending_batches[0]
                  .batch->payload->send_initial_metadata
                  .send_initial_metadata_flags;
+  // Apply service config to call if needed.
+  maybe_apply_service_config_to_call_locked(elem);
+  // When done, we schedule this closure to leave the channel combiner.
   GRPC_CLOSURE_INIT(&calld->pick_closure, pick_done, elem,
                     grpc_schedule_on_exec_ctx);
-  calld->request.Init(calld->owning_call, calld->call_combiner, calld->pollent,
-                      initial_metadata, initial_metadata_flags,
-                      maybe_apply_service_config_to_call_locked, elem,
-                      &calld->pick_closure);
-  calld->have_request = true;
-  chand->request_router->RouteCallLocked(calld->request.get());
+  // Attempt pick.
+  error = GRPC_ERROR_NONE;
+  auto pick_result = chand->picker->Pick(&calld->pick.pick, &error);
+  if (grpc_client_channel_trace.enabled()) {
+    gpr_log(GPR_INFO,
+            "chand=%p calld=%p: LB pick returned %s (connected_subchannel=%p, "
+            "error=%s)",
+            chand, calld, pick_result_name(pick_result),
+            calld->pick.pick.connected_subchannel.get(),
+            grpc_error_string(error));
+  }
+  switch (pick_result) {
+    case LoadBalancingPolicy::SubchannelPicker::PICK_TRANSIENT_FAILURE:
+      // If we're shutting down, fail all RPCs.
+      if (chand->disconnect_error != GRPC_ERROR_NONE) {
+        GRPC_ERROR_UNREF(error);
+        GRPC_CLOSURE_SCHED(&calld->pick_closure,
+                           GRPC_ERROR_REF(chand->disconnect_error));
+        break;
+      }
+      // If wait_for_ready is false, then the error indicates the RPC
+      // attempt's final status.
+      if ((*send_initial_metadata_flags &
+           GRPC_INITIAL_METADATA_WAIT_FOR_READY) == 0) {
+        // Retry if appropriate; otherwise, fail.
+        grpc_status_code status = GRPC_STATUS_OK;
+        grpc_error_get_status(error, calld->deadline, &status, nullptr, nullptr,
+                              nullptr);
+        if (!calld->enable_retries ||
+            !maybe_retry(elem, nullptr /* batch_data */, status,
+                         nullptr /* server_pushback_md */)) {
+          grpc_error* new_error =
+              GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                  "Failed to create subchannel", &error, 1);
+          GRPC_ERROR_UNREF(error);
+          GRPC_CLOSURE_SCHED(&calld->pick_closure, new_error);
+        }
+        if (calld->pick_queued) remove_call_from_queued_picks_locked(elem);
+        break;
+      }
+      // If wait_for_ready is true, then queue to retry when we get a new
+      // picker.
+      GRPC_ERROR_UNREF(error);
+      // Fallthrough
+    case LoadBalancingPolicy::SubchannelPicker::PICK_QUEUE:
+      if (!calld->pick_queued) add_call_to_queued_picks_locked(elem);
+      break;
+    default:  // PICK_COMPLETE
+      // Handle drops.
+      if (GPR_UNLIKELY(calld->pick.pick.connected_subchannel == nullptr)) {
+        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Call dropped by load balancing policy");
+      }
+      GRPC_CLOSURE_SCHED(&calld->pick_closure, error);
+      if (calld->pick_queued) remove_call_from_queued_picks_locked(elem);
+  }
 }
 
 //
@@ -2458,8 +2788,10 @@ static void cc_start_transport_stream_op_batch(
     // been started), fail all pending batches.  Otherwise, send the
     // cancellation down to the subchannel call.
     if (calld->subchannel_call == nullptr) {
+      // TODO(roth): If there is a pending retry callback, do we need to
+      // cancel it here?
       pending_batches_fail(elem, GRPC_ERROR_REF(calld->cancel_error),
-                           false /* yield_call_combiner */);
+                           no_yield_call_combiner);
       // Note: This will release the call combiner.
       grpc_transport_stream_op_batch_finish_with_failure(
           batch, GRPC_ERROR_REF(calld->cancel_error), calld->call_combiner);
@@ -2556,7 +2888,8 @@ const grpc_channel_filter grpc_client_channel_filter = {
 void grpc_client_channel_set_channelz_node(
     grpc_channel_element* elem, grpc_core::channelz::ClientChannelNode* node) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  chand->request_router->set_channelz_node(node);
+  chand->channelz_node = node;
+  chand->resolving_lb_policy->set_channelz_node(node->Ref());
 }
 
 void grpc_client_channel_populate_child_refs(
@@ -2564,22 +2897,23 @@ void grpc_client_channel_populate_child_refs(
     grpc_core::channelz::ChildRefsList* child_subchannels,
     grpc_core::channelz::ChildRefsList* child_channels) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (chand->request_router->lb_policy() != nullptr) {
-    chand->request_router->lb_policy()->FillChildRefsForChannelz(
-        child_subchannels, child_channels);
+  if (chand->resolving_lb_policy != nullptr) {
+    chand->resolving_lb_policy->FillChildRefsForChannelz(child_subchannels,
+                                                         child_channels);
   }
 }
 
 static void try_to_connect_locked(void* arg, grpc_error* error_ignored) {
   channel_data* chand = static_cast<channel_data*>(arg);
-  chand->request_router->ExitIdleLocked();
+  chand->resolving_lb_policy->ExitIdleLocked();
   GRPC_CHANNEL_STACK_UNREF(chand->owning_stack, "try_to_connect");
 }
 
 grpc_connectivity_state grpc_client_channel_check_connectivity_state(
     grpc_channel_element* elem, int try_to_connect) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_connectivity_state out = chand->request_router->GetConnectivityState();
+  grpc_connectivity_state out =
+      grpc_connectivity_state_check(&chand->state_tracker);
   if (out == GRPC_CHANNEL_IDLE && try_to_connect) {
     GRPC_CHANNEL_STACK_REF(chand->owning_stack, "try_to_connect");
     GRPC_CLOSURE_SCHED(
@@ -2688,15 +3022,15 @@ static void watch_connectivity_state_locked(void* arg,
     GRPC_CLOSURE_RUN(w->watcher_timer_init, GRPC_ERROR_NONE);
     GRPC_CLOSURE_INIT(&w->my_closure, on_external_watch_complete_locked, w,
                       grpc_combiner_scheduler(w->chand->combiner));
-    w->chand->request_router->NotifyOnConnectivityStateChange(w->state,
-                                                              &w->my_closure);
+    grpc_connectivity_state_notify_on_state_change(&w->chand->state_tracker,
+                                                   w->state, &w->my_closure);
   } else {
     GPR_ASSERT(w->watcher_timer_init == nullptr);
     found = lookup_external_connectivity_watcher(w->chand, w->on_complete);
     if (found) {
       GPR_ASSERT(found->on_complete == w->on_complete);
-      found->chand->request_router->NotifyOnConnectivityStateChange(
-          nullptr, &found->my_closure);
+      grpc_connectivity_state_notify_on_state_change(
+          &found->chand->state_tracker, nullptr, &found->my_closure);
     }
     grpc_polling_entity_del_from_pollset_set(&w->pollent,
                                              w->chand->interested_parties);

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

@@ -28,6 +28,17 @@ grpc_core::DebugOnlyTraceFlag grpc_trace_lb_policy_refcount(
 
 namespace grpc_core {
 
+LoadBalancingPolicy::LoadBalancingPolicy(Args args, intptr_t initial_refcount)
+    : InternallyRefCounted(&grpc_trace_lb_policy_refcount, initial_refcount),
+      combiner_(GRPC_COMBINER_REF(args.combiner, "lb_policy")),
+      interested_parties_(grpc_pollset_set_create()),
+      channel_control_helper_(std::move(args.channel_control_helper)) {}
+
+LoadBalancingPolicy::~LoadBalancingPolicy() {
+  grpc_pollset_set_destroy(interested_parties_);
+  GRPC_COMBINER_UNREF(combiner_, "lb_policy");
+}
+
 grpc_json* LoadBalancingPolicy::ParseLoadBalancingConfig(
     const grpc_json* lb_config_array) {
   if (lb_config_array == nullptr || lb_config_array->type != GRPC_JSON_ARRAY) {
@@ -54,35 +65,4 @@ grpc_json* LoadBalancingPolicy::ParseLoadBalancingConfig(
   return nullptr;
 }
 
-LoadBalancingPolicy::LoadBalancingPolicy(Args args)
-    : InternallyRefCounted(&grpc_trace_lb_policy_refcount),
-      combiner_(GRPC_COMBINER_REF(args.combiner, "lb_policy")),
-      client_channel_factory_(args.client_channel_factory),
-      subchannel_pool_(std::move(args.subchannel_pool)),
-      interested_parties_(grpc_pollset_set_create()),
-      request_reresolution_(nullptr) {}
-
-LoadBalancingPolicy::~LoadBalancingPolicy() {
-  grpc_pollset_set_destroy(interested_parties_);
-  GRPC_COMBINER_UNREF(combiner_, "lb_policy");
-}
-
-void LoadBalancingPolicy::TryReresolutionLocked(
-    grpc_core::TraceFlag* grpc_lb_trace, grpc_error* error) {
-  if (request_reresolution_ != nullptr) {
-    GRPC_CLOSURE_SCHED(request_reresolution_, error);
-    request_reresolution_ = nullptr;
-    if (grpc_lb_trace->enabled()) {
-      gpr_log(GPR_INFO,
-              "%s %p: scheduling re-resolution closure with error=%s.",
-              grpc_lb_trace->name(), this, grpc_error_string(error));
-    }
-  } else {
-    if (grpc_lb_trace->enabled()) {
-      gpr_log(GPR_INFO, "%s %p: no available re-resolution closure.",
-              grpc_lb_trace->name(), this);
-    }
-  }
-}
-
 }  // namespace grpc_core

src/core/ext/filters/client_channel/lb_policy.h

@@ -24,13 +24,13 @@
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/service_config.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_lb_policy_refcount;
 
@@ -43,61 +43,209 @@ namespace grpc_core {
 ///
 /// Any I/O done by the LB policy should be done under the pollset_set
 /// returned by \a interested_parties().
+// TODO(roth): Once we move to EventManager-based polling, remove the
+// interested_parties() hooks from the API.
 class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
  public:
-  struct Args {
-    /// The combiner under which all LB policy calls will be run.
-    /// Policy does NOT take ownership of the reference to the combiner.
-    // TODO(roth): Once we have a C++-like interface for combiners, this
-    // API should change to take a smart pointer that does pass ownership
-    // of a reference.
-    grpc_combiner* combiner = nullptr;
-    /// Used to create channels and subchannels.
-    grpc_client_channel_factory* client_channel_factory = nullptr;
-    /// Subchannel pool.
-    RefCountedPtr<SubchannelPoolInterface> subchannel_pool;
-    /// Channel args from the resolver.
-    /// Note that the LB policy gets the set of addresses from the
-    /// GRPC_ARG_SERVER_ADDRESS_LIST channel arg.
-    grpc_channel_args* args = nullptr;
-    /// Load balancing config from the resolver.
-    grpc_json* lb_config = nullptr;
-  };
-
   /// State used for an LB pick.
   struct PickState {
     /// Initial metadata associated with the picking call.
+    /// This is both an input and output parameter; the LB policy may
+    /// use metadata here to influence its routing decision, and it may
+    /// add new metadata here to be sent with the call to the chosen backend.
     grpc_metadata_batch* initial_metadata = nullptr;
-    /// Pointer to bitmask used for selective cancelling. See
-    /// \a CancelMatchingPicksLocked() and \a GRPC_INITIAL_METADATA_* in
-    /// grpc_types.h.
-    uint32_t* initial_metadata_flags = nullptr;
     /// Storage for LB token in \a initial_metadata, or nullptr if not used.
+    // TODO(roth): Remove this from the API.  Maybe have the LB policy
+    // allocate this on the arena instead?
     grpc_linked_mdelem lb_token_mdelem_storage;
-    /// Closure to run when pick is complete, if not completed synchronously.
-    /// If null, pick will fail if a result is not available synchronously.
-    grpc_closure* on_complete = nullptr;
-    // Callback set by lb policy to be notified of trailing metadata.
-    // The callback must be scheduled on grpc_schedule_on_exec_ctx.
+    /// Callback set by lb policy to be notified of trailing metadata.
+    /// The callback must be scheduled on grpc_schedule_on_exec_ctx.
     grpc_closure* recv_trailing_metadata_ready = nullptr;
-    // The address that will be set to point to the original
-    // recv_trailing_metadata_ready callback, to be invoked by the LB
-    // policy's recv_trailing_metadata_ready callback when complete.
-    // Must be non-null if recv_trailing_metadata_ready is non-null.
+    /// The address that will be set to point to the original
+    /// recv_trailing_metadata_ready callback, to be invoked by the LB
+    /// policy's recv_trailing_metadata_ready callback when complete.
+    /// Must be non-null if recv_trailing_metadata_ready is non-null.
     grpc_closure** original_recv_trailing_metadata_ready = nullptr;
-    // If this is not nullptr, then the client channel will point it to the
-    // call's trailing metadata before invoking recv_trailing_metadata_ready.
-    // If this is nullptr, then the callback will still be called.
-    // The lb does not have ownership of the metadata.
+    /// If this is not nullptr, then the client channel will point it to the
+    /// call's trailing metadata before invoking recv_trailing_metadata_ready.
+    /// If this is nullptr, then the callback will still be called.
+    /// The lb does not have ownership of the metadata.
     grpc_metadata_batch** recv_trailing_metadata = nullptr;
     /// Will be set to the selected subchannel, or nullptr on failure or when
     /// the LB policy decides to drop the call.
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     /// Will be populated with context to pass to the subchannel call, if
     /// needed.
+    // TODO(roth): Remove this from the API, especially since it's not
+    // working properly anyway (see https://github.com/grpc/grpc/issues/15927).
     grpc_call_context_element subchannel_call_context[GRPC_CONTEXT_COUNT] = {};
-    /// Next pointer.  For internal use by LB policy.
-    PickState* next = nullptr;
+  };
+
+  /// A picker is the object used to actual perform picks.
+  ///
+  /// Pickers are intended to encapsulate all of the state and logic
+  /// needed on the data plane (i.e., to actually process picks for
+  /// individual RPCs sent on the channel) while excluding all of the
+  /// state and logic needed on the control plane (i.e., resolver
+  /// updates, connectivity state notifications, etc); the latter should
+  /// live in the LB policy object itself.
+  ///
+  /// Currently, pickers are always accessed from within the
+  /// client_channel combiner, so they do not have to be thread-safe.
+  // TODO(roth): In a subsequent PR, split the data plane work (i.e.,
+  // the interaction with the picker) and the control plane work (i.e.,
+  // the interaction with the LB policy) into two different
+  // synchronization mechanisms, to avoid lock contention between the two.
+  class SubchannelPicker {
+   public:
+    enum PickResult {
+      // Pick complete.  If connected_subchannel is non-null, client channel
+      // can immediately proceed with the call on connected_subchannel;
+      // otherwise, call should be dropped.
+      PICK_COMPLETE,
+      // Pick cannot be completed until something changes on the control
+      // plane.  Client channel will queue the pick and try again the
+      // next time the picker is updated.
+      PICK_QUEUE,
+      // LB policy is in transient failure.  If the pick is wait_for_ready,
+      // client channel will wait for the next picker and try again;
+      // otherwise, the call will be failed immediately (although it may
+      // be retried if the client channel is configured to do so).
+      // The Pick() method will set its error parameter if this value is
+      // returned.
+      PICK_TRANSIENT_FAILURE,
+    };
+
+    SubchannelPicker() = default;
+    virtual ~SubchannelPicker() = default;
+
+    virtual PickResult Pick(PickState* pick, grpc_error** error) GRPC_ABSTRACT;
+
+    GRPC_ABSTRACT_BASE_CLASS
+  };
+
+  // A picker that returns PICK_QUEUE for all picks.
+  // Also calls the parent LB policy's ExitIdleLocked() method when the
+  // first pick is seen.
+  class QueuePicker : public SubchannelPicker {
+   public:
+    explicit QueuePicker(RefCountedPtr<LoadBalancingPolicy> parent)
+        : parent_(std::move(parent)) {}
+
+    PickResult Pick(PickState* pick, grpc_error** error) override {
+      // We invoke the parent's ExitIdleLocked() via a closure instead
+      // of doing it directly here, for two reasons:
+      // 1. ExitIdleLocked() may cause the policy's state to change and
+      //    a new picker to be delivered to the channel.  If that new
+      //    picker is delivered before ExitIdleLocked() returns, then by
+      //    the time this function returns, the pick will already have
+      //    been processed, and we'll be trying to re-process the same
+      //    pick again, leading to a crash.
+      // 2. In a subsequent PR, we will split the data plane and control
+      //    plane synchronization into separate combiners, at which
+      //    point this will need to hop from the data plane combiner into
+      //    the control plane combiner.
+      if (!exit_idle_called_) {
+        exit_idle_called_ = true;
+        parent_->Ref().release();  // ref held by closure.
+        GRPC_CLOSURE_SCHED(
+            GRPC_CLOSURE_CREATE(&CallExitIdle, parent_.get(),
+                                grpc_combiner_scheduler(parent_->combiner())),
+            GRPC_ERROR_NONE);
+      }
+      return PICK_QUEUE;
+    }
+
+   private:
+    static void CallExitIdle(void* arg, grpc_error* error) {
+      LoadBalancingPolicy* parent = static_cast<LoadBalancingPolicy*>(arg);
+      parent->ExitIdleLocked();
+      parent->Unref();
+    }
+
+    RefCountedPtr<LoadBalancingPolicy> parent_;
+    bool exit_idle_called_ = false;
+  };
+
+  // A picker that returns PICK_TRANSIENT_FAILURE for all picks.
+  class TransientFailurePicker : public SubchannelPicker {
+   public:
+    explicit TransientFailurePicker(grpc_error* error) : error_(error) {}
+    ~TransientFailurePicker() { GRPC_ERROR_UNREF(error_); }
+
+    PickResult Pick(PickState* pick, grpc_error** error) override {
+      *error = GRPC_ERROR_REF(error_);
+      return PICK_TRANSIENT_FAILURE;
+    }
+
+   private:
+    grpc_error* error_;
+  };
+
+  /// A proxy object used by the LB policy to communicate with the client
+  /// channel.
+  class ChannelControlHelper {
+   public:
+    ChannelControlHelper() = default;
+    virtual ~ChannelControlHelper() = default;
+
+    /// Creates a new subchannel with the specified channel args.
+    virtual Subchannel* CreateSubchannel(const grpc_channel_args& args)
+        GRPC_ABSTRACT;
+
+    /// Creates a channel with the specified target, type, and channel args.
+    virtual grpc_channel* CreateChannel(
+        const char* target, grpc_client_channel_type type,
+        const grpc_channel_args& args) GRPC_ABSTRACT;
+
+    /// Sets the connectivity state and returns a new picker to be used
+    /// by the client channel.
+    virtual void UpdateState(grpc_connectivity_state state,
+                             grpc_error* state_error,
+                             UniquePtr<SubchannelPicker> picker) {
+      std::move(picker);  // Suppress clang-tidy complaint.
+      // The rest of this is copied from the GRPC_ABSTRACT macro.
+      gpr_log(GPR_ERROR, "Function marked GRPC_ABSTRACT was not implemented");
+      GPR_ASSERT(false);
+    }
+
+    /// Requests that the resolver re-resolve.
+    virtual void RequestReresolution() GRPC_ABSTRACT;
+
+    GRPC_ABSTRACT_BASE_CLASS
+  };
+
+  // Configuration for an LB policy instance.
+  class Config : public RefCounted<Config> {
+   public:
+    Config(const grpc_json* lb_config,
+           RefCountedPtr<ServiceConfig> service_config)
+        : json_(lb_config), service_config_(std::move(service_config)) {}
+
+    const grpc_json* json() const { return json_; }
+    RefCountedPtr<ServiceConfig> service_config() const {
+      return service_config_;
+    }
+
+   private:
+    const grpc_json* json_;
+    RefCountedPtr<ServiceConfig> service_config_;
+  };
+
+  /// Args used to instantiate an LB policy.
+  struct Args {
+    /// The combiner under which all LB policy calls will be run.
+    /// Policy does NOT take ownership of the reference to the combiner.
+    // TODO(roth): Once we have a C++-like interface for combiners, this
+    // API should change to take a smart pointer that does pass ownership
+    // of a reference.
+    grpc_combiner* combiner = nullptr;
+    /// Channel control helper.
+    /// Note: LB policies MUST NOT call any method on the helper from
+    /// their constructor.
+    UniquePtr<ChannelControlHelper> channel_control_helper;
+    /// Channel args.
+    const grpc_channel_args* args = nullptr;
   };
 
   // Not copyable nor movable.
@@ -108,57 +256,20 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   virtual const char* name() const GRPC_ABSTRACT;
 
   /// Updates the policy with a new set of \a args and a new \a lb_config from
-  /// the resolver. Note that the LB policy gets the set of addresses from the
+  /// the resolver. Will be invoked immediately after LB policy is constructed,
+  /// and then again whenever the resolver returns a new result.
+  /// Note that the LB policy gets the set of addresses from the
   /// GRPC_ARG_SERVER_ADDRESS_LIST channel arg.
   virtual void UpdateLocked(const grpc_channel_args& args,
-                            grpc_json* lb_config) GRPC_ABSTRACT;
-
-  /// Finds an appropriate subchannel for a call, based on data in \a pick.
-  /// \a pick must remain alive until the pick is complete.
-  ///
-  /// If a result is known immediately, returns true, setting \a *error
-  /// upon failure.  Otherwise, \a pick->on_complete will be invoked once
-  /// the pick is complete with its error argument set to indicate success
-  /// or failure.
-  ///
-  /// If \a pick->on_complete is null and no result is known immediately,
-  /// a synchronous failure will be returned (i.e., \a *error will be
-  /// set and true will be returned).
-  virtual bool PickLocked(PickState* pick, grpc_error** error) GRPC_ABSTRACT;
-
-  /// Cancels \a pick.
-  /// The \a on_complete callback of the pending pick will be invoked with
-  /// \a pick->connected_subchannel set to null.
-  virtual void CancelPickLocked(PickState* pick,
-                                grpc_error* error) GRPC_ABSTRACT;
-
-  /// Cancels all pending picks for which their \a initial_metadata_flags (as
-  /// given in the call to \a PickLocked()) matches
-  /// \a initial_metadata_flags_eq when ANDed with
-  /// \a initial_metadata_flags_mask.
-  virtual void CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                         uint32_t initial_metadata_flags_eq,
-                                         grpc_error* error) GRPC_ABSTRACT;
-
-  /// Requests a notification when the connectivity state of the policy
-  /// changes from \a *state.  When that happens, sets \a *state to the
-  /// new state and schedules \a closure.
-  virtual void NotifyOnStateChangeLocked(grpc_connectivity_state* state,
-                                         grpc_closure* closure) GRPC_ABSTRACT;
-
-  /// Returns the policy's current connectivity state.  Sets \a error to
-  /// the associated error, if any.
-  virtual grpc_connectivity_state CheckConnectivityLocked(
-      grpc_error** connectivity_error) GRPC_ABSTRACT;
-
-  /// Hands off pending picks to \a new_policy.
-  virtual void HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy)
-      GRPC_ABSTRACT;
+                            RefCountedPtr<Config> lb_config) {
+    std::move(lb_config);  // Suppress clang-tidy complaint.
+    GRPC_ABSTRACT;
+  }
 
   /// Tries to enter a READY connectivity state.
-  /// TODO(roth): As part of restructuring how we handle IDLE state,
-  /// consider whether this method is still needed.
-  virtual void ExitIdleLocked() GRPC_ABSTRACT;
+  /// This is a no-op by default, since most LB policies never go into
+  /// IDLE state.
+  virtual void ExitIdleLocked() {}
 
   /// Resets connection backoff.
   virtual void ResetBackoffLocked() GRPC_ABSTRACT;
@@ -183,18 +294,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// given the JSON node of a LoadBalancingConfig array.
   static grpc_json* ParseLoadBalancingConfig(const grpc_json* lb_config_array);
 
-  /// Sets the re-resolution closure to \a request_reresolution.
-  void SetReresolutionClosureLocked(grpc_closure* request_reresolution) {
-    GPR_ASSERT(request_reresolution_ == nullptr);
-    request_reresolution_ = request_reresolution;
-  }
-
   grpc_pollset_set* interested_parties() const { return interested_parties_; }
 
-  // Callers that need their own reference can call the returned
-  // object's Ref() method.
-  SubchannelPoolInterface* subchannel_pool() const {
-    return subchannel_pool_.get();
+  void set_channelz_node(
+      RefCountedPtr<channelz::ClientChannelNode> channelz_node) {
+    channelz_node_ = std::move(channelz_node);
   }
 
   GRPC_ABSTRACT_BASE_CLASS
@@ -202,12 +306,20 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
  protected:
   GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
 
-  explicit LoadBalancingPolicy(Args args);
+  explicit LoadBalancingPolicy(Args args, intptr_t initial_refcount = 1);
   virtual ~LoadBalancingPolicy();
 
   grpc_combiner* combiner() const { return combiner_; }
-  grpc_client_channel_factory* client_channel_factory() const {
-    return client_channel_factory_;
+
+  // Note: LB policies MUST NOT call any method on the helper from
+  // their constructor.
+  // Note: This will return null after ShutdownLocked() has been called.
+  ChannelControlHelper* channel_control_helper() const {
+    return channel_control_helper_.get();
+  }
+
+  channelz::ClientChannelNode* channelz_node() const {
+    return channelz_node_.get();
   }
 
   /// Shuts down the policy.  Any pending picks that have not been
@@ -215,27 +327,22 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// failed.
   virtual void ShutdownLocked() GRPC_ABSTRACT;
 
-  /// Tries to request a re-resolution.
-  void TryReresolutionLocked(grpc_core::TraceFlag* grpc_lb_trace,
-                             grpc_error* error);
-
  private:
   static void ShutdownAndUnrefLocked(void* arg, grpc_error* ignored) {
     LoadBalancingPolicy* policy = static_cast<LoadBalancingPolicy*>(arg);
     policy->ShutdownLocked();
+    policy->channel_control_helper_.reset();
     policy->Unref();
   }
 
   /// Combiner under which LB policy actions take place.
   grpc_combiner* combiner_;
-  /// Client channel factory, used to create channels and subchannels.
-  grpc_client_channel_factory* client_channel_factory_;
-  /// Subchannel pool.
-  RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
   /// Owned pointer to interested parties in load balancing decisions.
   grpc_pollset_set* interested_parties_;
-  /// Callback to force a re-resolution.
-  grpc_closure* request_reresolution_;
+  /// Channel control helper.
+  UniquePtr<ChannelControlHelper> channel_control_helper_;
+  /// Channelz node.
+  RefCountedPtr<channelz::ClientChannelNode> channelz_node_;
 };
 
 }  // namespace grpc_core

src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.cc

@@ -43,7 +43,7 @@ void GrpcLbClientStats::AddCallFinished(
   }
 }
 
-void GrpcLbClientStats::AddCallDroppedLocked(char* token) {
+void GrpcLbClientStats::AddCallDroppedLocked(const char* token) {
   // Increment num_calls_started and num_calls_finished.
   gpr_atm_full_fetch_add(&num_calls_started_, (gpr_atm)1);
   gpr_atm_full_fetch_add(&num_calls_finished_, (gpr_atm)1);

src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h

@@ -48,7 +48,7 @@ class GrpcLbClientStats : public RefCounted<GrpcLbClientStats> {
                        bool finished_known_received);
 
   // This method is not thread-safe; caller must synchronize.
-  void AddCallDroppedLocked(char* token);
+  void AddCallDroppedLocked(const char* token);
 
   // This method is not thread-safe; caller must synchronize.
   void GetLocked(int64_t* num_calls_started, int64_t* num_calls_finished,

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

@@ -51,17 +51,7 @@ class PickFirst : public LoadBalancingPolicy {
   const char* name() const override { return kPickFirst; }
 
   void UpdateLocked(const grpc_channel_args& args,
-                    grpc_json* lb_config) override;
-  bool PickLocked(PickState* pick, grpc_error** error) override;
-  void CancelPickLocked(PickState* pick, grpc_error* error) override;
-  void CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                 uint32_t initial_metadata_flags_eq,
-                                 grpc_error* error) override;
-  void NotifyOnStateChangeLocked(grpc_connectivity_state* state,
-                                 grpc_closure* closure) override;
-  grpc_connectivity_state CheckConnectivityLocked(
-      grpc_error** connectivity_error) override;
-  void HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) override;
+                    RefCountedPtr<Config> lb_config) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
   void FillChildRefsForChannelz(channelz::ChildRefsList* child_subchannels,
@@ -99,10 +89,9 @@ class PickFirst : public LoadBalancingPolicy {
     PickFirstSubchannelList(PickFirst* policy, TraceFlag* tracer,
                             const ServerAddressList& addresses,
                             grpc_combiner* combiner,
-                            grpc_client_channel_factory* client_channel_factory,
                             const grpc_channel_args& args)
         : SubchannelList(policy, tracer, addresses, combiner,
-                         client_channel_factory, args) {
+                         policy->channel_control_helper(), args) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -115,6 +104,20 @@ class PickFirst : public LoadBalancingPolicy {
     }
   };
 
+  class Picker : public SubchannelPicker {
+   public:
+    explicit Picker(RefCountedPtr<ConnectedSubchannel> connected_subchannel)
+        : connected_subchannel_(std::move(connected_subchannel)) {}
+
+    PickResult Pick(PickState* pick, grpc_error** error) override {
+      pick->connected_subchannel = connected_subchannel_;
+      return PICK_COMPLETE;
+    }
+
+   private:
+    RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  };
+
   // Helper class to ensure that any function that modifies the child refs
   // data structures will update the channelz snapshot data structures before
   // returning.
@@ -129,7 +132,6 @@ class PickFirst : public LoadBalancingPolicy {
 
   void ShutdownLocked() override;
 
-  void StartPickingLocked();
   void UpdateChildRefsLocked();
 
   // All our subchannels.
@@ -138,14 +140,10 @@ class PickFirst : public LoadBalancingPolicy {
   OrphanablePtr<PickFirstSubchannelList> latest_pending_subchannel_list_;
   // Selected subchannel in \a subchannel_list_.
   PickFirstSubchannelData* selected_ = nullptr;
-  // Have we started picking?
-  bool started_picking_ = false;
+  // Are we in IDLE state?
+  bool idle_ = false;
   // Are we shut down?
   bool shutdown_ = false;
-  // List of picks that are waiting on connectivity.
-  PickState* pending_picks_ = nullptr;
-  // Our connectivity state tracker.
-  grpc_connectivity_state_tracker state_tracker_;
 
   /// Lock and data used to capture snapshots of this channels child
   /// channels and subchannels. This data is consumed by channelz.
@@ -155,14 +153,10 @@ class PickFirst : public LoadBalancingPolicy {
 };
 
 PickFirst::PickFirst(Args args) : LoadBalancingPolicy(std::move(args)) {
-  GPR_ASSERT(args.client_channel_factory != nullptr);
   gpr_mu_init(&child_refs_mu_);
-  grpc_connectivity_state_init(&state_tracker_, GRPC_CHANNEL_IDLE,
-                               "pick_first");
   if (grpc_lb_pick_first_trace.enabled()) {
     gpr_log(GPR_INFO, "Pick First %p created.", this);
   }
-  UpdateLocked(*args.args, args.lb_config);
 }
 
 PickFirst::~PickFirst() {
@@ -172,94 +166,26 @@ PickFirst::~PickFirst() {
   gpr_mu_destroy(&child_refs_mu_);
   GPR_ASSERT(subchannel_list_ == nullptr);
   GPR_ASSERT(latest_pending_subchannel_list_ == nullptr);
-  GPR_ASSERT(pending_picks_ == nullptr);
-  grpc_connectivity_state_destroy(&state_tracker_);
-}
-
-void PickFirst::HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) {
-  PickState* pick;
-  while ((pick = pending_picks_) != nullptr) {
-    pending_picks_ = pick->next;
-    grpc_error* error = GRPC_ERROR_NONE;
-    if (new_policy->PickLocked(pick, &error)) {
-      // Synchronous return, schedule closure.
-      GRPC_CLOSURE_SCHED(pick->on_complete, error);
-    }
-  }
 }
 
 void PickFirst::ShutdownLocked() {
   AutoChildRefsUpdater guard(this);
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel shutdown");
   if (grpc_lb_pick_first_trace.enabled()) {
     gpr_log(GPR_INFO, "Pick First %p Shutting down", this);
   }
   shutdown_ = true;
-  PickState* pick;
-  while ((pick = pending_picks_) != nullptr) {
-    pending_picks_ = pick->next;
-    pick->connected_subchannel.reset();
-    GRPC_CLOSURE_SCHED(pick->on_complete, GRPC_ERROR_REF(error));
-  }
-  grpc_connectivity_state_set(&state_tracker_, GRPC_CHANNEL_SHUTDOWN,
-                              GRPC_ERROR_REF(error), "shutdown");
   subchannel_list_.reset();
   latest_pending_subchannel_list_.reset();
-  TryReresolutionLocked(&grpc_lb_pick_first_trace, GRPC_ERROR_CANCELLED);
-  GRPC_ERROR_UNREF(error);
-}
-
-void PickFirst::CancelPickLocked(PickState* pick, grpc_error* error) {
-  PickState* pp = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pp != nullptr) {
-    PickState* next = pp->next;
-    if (pp == pick) {
-      pick->connected_subchannel.reset();
-      GRPC_CLOSURE_SCHED(pick->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pp->next = pending_picks_;
-      pending_picks_ = pp;
-    }
-    pp = next;
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void PickFirst::CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                          uint32_t initial_metadata_flags_eq,
-                                          grpc_error* error) {
-  PickState* pick = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pick != nullptr) {
-    PickState* next = pick->next;
-    if ((*pick->initial_metadata_flags & initial_metadata_flags_mask) ==
-        initial_metadata_flags_eq) {
-      GRPC_CLOSURE_SCHED(pick->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pick->next = pending_picks_;
-      pending_picks_ = pick;
-    }
-    pick = next;
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void PickFirst::StartPickingLocked() {
-  started_picking_ = true;
-  if (subchannel_list_ != nullptr && subchannel_list_->num_subchannels() > 0) {
-    subchannel_list_->subchannel(0)
-        ->CheckConnectivityStateAndStartWatchingLocked();
-  }
 }
 
 void PickFirst::ExitIdleLocked() {
-  if (!started_picking_) {
-    StartPickingLocked();
+  if (idle_) {
+    idle_ = false;
+    if (subchannel_list_ != nullptr &&
+        subchannel_list_->num_subchannels() > 0) {
+      subchannel_list_->subchannel(0)
+          ->CheckConnectivityStateAndStartWatchingLocked();
+    }
   }
 }
 
@@ -270,36 +196,6 @@ void PickFirst::ResetBackoffLocked() {
   }
 }
 
-bool PickFirst::PickLocked(PickState* pick, grpc_error** error) {
-  // If we have a selected subchannel already, return synchronously.
-  if (selected_ != nullptr) {
-    pick->connected_subchannel = selected_->connected_subchannel()->Ref();
-    return true;
-  }
-  // No subchannel selected yet, so handle asynchronously.
-  if (pick->on_complete == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No pick result available but synchronous result required.");
-    return true;
-  }
-  pick->next = pending_picks_;
-  pending_picks_ = pick;
-  if (!started_picking_) {
-    StartPickingLocked();
-  }
-  return false;
-}
-
-grpc_connectivity_state PickFirst::CheckConnectivityLocked(grpc_error** error) {
-  return grpc_connectivity_state_get(&state_tracker_, error);
-}
-
-void PickFirst::NotifyOnStateChangeLocked(grpc_connectivity_state* current,
-                                          grpc_closure* notify) {
-  grpc_connectivity_state_notify_on_state_change(&state_tracker_, current,
-                                                 notify);
-}
-
 void PickFirst::FillChildRefsForChannelz(
     channelz::ChildRefsList* child_subchannels_to_fill,
     channelz::ChildRefsList* ignored) {
@@ -335,16 +231,17 @@ void PickFirst::UpdateChildRefsLocked() {
 }
 
 void PickFirst::UpdateLocked(const grpc_channel_args& args,
-                             grpc_json* lb_config) {
+                             RefCountedPtr<Config> lb_config) {
   AutoChildRefsUpdater guard(this);
   const ServerAddressList* addresses = FindServerAddressListChannelArg(&args);
   if (addresses == nullptr) {
     if (subchannel_list_ == nullptr) {
       // If we don't have a current subchannel list, go into TRANSIENT FAILURE.
-      grpc_connectivity_state_set(
-          &state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing update in args"),
-          "pf_update_missing");
+      grpc_error* error =
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing update in args");
+      channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(error),
+          UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(error)));
     } else {
       // otherwise, keep using the current subchannel list (ignore this update).
       gpr_log(GPR_ERROR,
@@ -364,25 +261,26 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args,
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add(&args, &new_arg, 1);
   auto subchannel_list = MakeOrphanable<PickFirstSubchannelList>(
-      this, &grpc_lb_pick_first_trace, *addresses, combiner(),
-      client_channel_factory(), *new_args);
+      this, &grpc_lb_pick_first_trace, *addresses, combiner(), *new_args);
   grpc_channel_args_destroy(new_args);
   if (subchannel_list->num_subchannels() == 0) {
     // Empty update or no valid subchannels. Unsubscribe from all current
     // subchannels and put the channel in TRANSIENT_FAILURE.
-    grpc_connectivity_state_set(
-        &state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update"),
-        "pf_update_empty");
     subchannel_list_ = std::move(subchannel_list);  // Empty list.
     selected_ = nullptr;
+    grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update");
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(error),
+        UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(error)));
     return;
   }
   // If one of the subchannels in the new list is already in state
   // READY, then select it immediately.  This can happen when the
   // currently selected subchannel is also present in the update.  It
   // can also happen if one of the subchannels in the update is already
-  // in the subchannel index because it's in use by another channel.
+  // in the global subchannel pool because it's in use by another channel.
+  // TODO(roth): If we're in IDLE state, we should probably defer this
+  // check and instead do it in ExitIdleLocked().
   for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
     PickFirstSubchannelData* sd = subchannel_list->subchannel(i);
     grpc_error* error = GRPC_ERROR_NONE;
@@ -390,8 +288,8 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args,
     GRPC_ERROR_UNREF(error);
     if (state == GRPC_CHANNEL_READY) {
       subchannel_list_ = std::move(subchannel_list);
-      sd->ProcessUnselectedReadyLocked();
       sd->StartConnectivityWatchLocked();
+      sd->ProcessUnselectedReadyLocked();
       // If there was a previously pending update (which may or may
       // not have contained the currently selected subchannel), drop
       // it, so that it doesn't override what we've done here.
@@ -399,7 +297,7 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args,
       // Make sure that subsequent calls to ExitIdleLocked() don't cause
       // us to start watching a subchannel other than the one we've
       // selected.
-      started_picking_ = true;
+      idle_ = false;
       return;
     }
   }
@@ -407,17 +305,17 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args,
     // We don't yet have a selected subchannel, so replace the current
     // subchannel list immediately.
     subchannel_list_ = std::move(subchannel_list);
-    // If we've started picking, start trying to connect to the first
+    // If we're not in IDLE state, start trying to connect to the first
     // subchannel in the new list.
-    if (started_picking_) {
+    if (!idle_) {
       // Note: No need to use CheckConnectivityStateAndStartWatchingLocked()
       // here, since we've already checked the initial connectivity
       // state of all subchannels above.
       subchannel_list_->subchannel(0)->StartConnectivityWatchLocked();
     }
   } else {
-    // We do have a selected subchannel, so keep using it until one of
-    // the subchannels in the new list reports READY.
+    // We do have a selected subchannel (which means it's READY), so keep
+    // using it until one of the subchannels in the new list reports READY.
     if (latest_pending_subchannel_list_ != nullptr) {
       if (grpc_lb_pick_first_trace.enabled()) {
         gpr_log(GPR_INFO,
@@ -428,9 +326,9 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args,
       }
     }
     latest_pending_subchannel_list_ = std::move(subchannel_list);
-    // If we've started picking, start trying to connect to the first
+    // If we're not in IDLE state, start trying to connect to the first
     // subchannel in the new list.
-    if (started_picking_) {
+    if (!idle_) {
       // Note: No need to use CheckConnectivityStateAndStartWatchingLocked()
       // here, since we've already checked the initial connectivity
       // state of all subchannels above.
@@ -453,7 +351,8 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
   if (p->selected_ == this) {
     if (grpc_lb_pick_first_trace.enabled()) {
       gpr_log(GPR_INFO,
-              "Pick First %p connectivity changed for selected subchannel", p);
+              "Pick First %p selected subchannel connectivity changed to %s", p,
+              grpc_connectivity_state_name(connectivity_state));
     }
     // If the new state is anything other than READY and there is a
     // pending update, switch to the pending update.
@@ -469,32 +368,40 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
       p->selected_ = nullptr;
       StopConnectivityWatchLocked();
       p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
-      grpc_connectivity_state_set(
-          &p->state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-          error != GRPC_ERROR_NONE
-              ? GRPC_ERROR_REF(error)
-              : GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                    "selected subchannel not ready; switching to pending "
-                    "update"),
-          "selected_not_ready+switch_to_update");
+      grpc_error* new_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+          "selected subchannel not ready; switching to pending update", &error,
+          1);
+      p->channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(new_error),
+          UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(new_error)));
     } else {
       if (connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-        // If the selected subchannel goes bad, request a re-resolution. We also
-        // set the channel state to IDLE and reset started_picking_. The reason
-        // is that if the new state is TRANSIENT_FAILURE due to a GOAWAY
-        // reception we don't want to connect to the re-resolved backends until
-        // we leave the IDLE state.
-        grpc_connectivity_state_set(&p->state_tracker_, GRPC_CHANNEL_IDLE,
-                                    GRPC_ERROR_NONE,
-                                    "selected_changed+reresolve");
-        p->started_picking_ = false;
-        p->TryReresolutionLocked(&grpc_lb_pick_first_trace, GRPC_ERROR_NONE);
+        // If the selected subchannel goes bad, request a re-resolution. We
+        // also set the channel state to IDLE. The reason is that if the new
+        // state is TRANSIENT_FAILURE due to a GOAWAY reception we don't want
+        // to connect to the re-resolved backends until we leave IDLE state.
+        p->idle_ = true;
+        p->channel_control_helper()->RequestReresolution();
         // In transient failure. Rely on re-resolution to recover.
         p->selected_ = nullptr;
         StopConnectivityWatchLocked();
+        p->channel_control_helper()->UpdateState(
+            GRPC_CHANNEL_IDLE, GRPC_ERROR_NONE,
+            UniquePtr<SubchannelPicker>(New<QueuePicker>(p->Ref())));
       } else {
-        grpc_connectivity_state_set(&p->state_tracker_, connectivity_state,
-                                    GRPC_ERROR_REF(error), "selected_changed");
+        // 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, GRPC_ERROR_NONE,
+              UniquePtr<SubchannelPicker>(
+                  New<Picker>(connected_subchannel()->Ref())));
+        } else {  // CONNECTING
+          p->channel_control_helper()->UpdateState(
+              connectivity_state, GRPC_ERROR_REF(error),
+              UniquePtr<SubchannelPicker>(New<QueuePicker>(p->Ref())));
+        }
         // Renew notification.
         RenewConnectivityWatchLocked();
       }
@@ -513,9 +420,9 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
   //    select in place of the current one.
   switch (connectivity_state) {
     case GRPC_CHANNEL_READY: {
-      ProcessUnselectedReadyLocked();
       // Renew notification.
       RenewConnectivityWatchLocked();
+      ProcessUnselectedReadyLocked();
       break;
     }
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
@@ -527,10 +434,14 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
       // Case 1: Only set state to TRANSIENT_FAILURE if we've tried
       // all subchannels.
       if (sd->Index() == 0 && subchannel_list() == p->subchannel_list_.get()) {
-        p->TryReresolutionLocked(&grpc_lb_pick_first_trace, GRPC_ERROR_NONE);
-        grpc_connectivity_state_set(
-            &p->state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-            GRPC_ERROR_REF(error), "exhausted_subchannels");
+        p->channel_control_helper()->RequestReresolution();
+        grpc_error* new_error =
+            GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                "failed to connect to all addresses", &error, 1);
+        p->channel_control_helper()->UpdateState(
+            GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(new_error),
+            UniquePtr<SubchannelPicker>(
+                New<TransientFailurePicker>(new_error)));
       }
       sd->CheckConnectivityStateAndStartWatchingLocked();
       break;
@@ -539,9 +450,9 @@ void PickFirst::PickFirstSubchannelData::ProcessConnectivityChangeLocked(
     case GRPC_CHANNEL_IDLE: {
       // Only update connectivity state in case 1.
       if (subchannel_list() == p->subchannel_list_.get()) {
-        grpc_connectivity_state_set(&p->state_tracker_, GRPC_CHANNEL_CONNECTING,
-                                    GRPC_ERROR_REF(error),
-                                    "connecting_changed");
+        p->channel_control_helper()->UpdateState(
+            GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE,
+            UniquePtr<SubchannelPicker>(New<QueuePicker>(p->Ref())));
       }
       // Renew notification.
       RenewConnectivityWatchLocked();
@@ -578,38 +489,30 @@ void PickFirst::PickFirstSubchannelData::ProcessUnselectedReadyLocked() {
     p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
   }
   // Cases 1 and 2.
-  grpc_connectivity_state_set(&p->state_tracker_, GRPC_CHANNEL_READY,
-                              GRPC_ERROR_NONE, "subchannel_ready");
   p->selected_ = this;
+  p->channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_READY, GRPC_ERROR_NONE,
+      UniquePtr<SubchannelPicker>(New<Picker>(connected_subchannel()->Ref())));
   if (grpc_lb_pick_first_trace.enabled()) {
     gpr_log(GPR_INFO, "Pick First %p selected subchannel %p", p, subchannel());
   }
-  // Update any calls that were waiting for a pick.
-  PickState* pick;
-  while ((pick = p->pending_picks_)) {
-    p->pending_picks_ = pick->next;
-    pick->connected_subchannel = p->selected_->connected_subchannel()->Ref();
-    if (grpc_lb_pick_first_trace.enabled()) {
-      gpr_log(GPR_INFO, "Servicing pending pick with selected subchannel %p",
-              p->selected_->subchannel());
-    }
-    GRPC_CLOSURE_SCHED(pick->on_complete, GRPC_ERROR_NONE);
-  }
 }
 
 void PickFirst::PickFirstSubchannelData::
     CheckConnectivityStateAndStartWatchingLocked() {
   PickFirst* p = static_cast<PickFirst*>(subchannel_list()->policy());
+  // Check current state.
   grpc_error* error = GRPC_ERROR_NONE;
-  if (p->selected_ != this &&
-      CheckConnectivityStateLocked(&error) == GRPC_CHANNEL_READY) {
-    // We must process the READY subchannel before we start watching it.
-    // Otherwise, we won't know it's READY because we will be waiting for its
-    // connectivity state to change from READY.
-    ProcessUnselectedReadyLocked();
-  }
+  grpc_connectivity_state current_state = CheckConnectivityStateLocked(&error);
   GRPC_ERROR_UNREF(error);
+  // Start watch.
   StartConnectivityWatchLocked();
+  // If current state is READY, select the subchannel now, since we started
+  // watching from this state and will not get a notification of it
+  // transitioning into this state.
+  if (p->selected_ != this && current_state == GRPC_CHANNEL_READY) {
+    ProcessUnselectedReadyLocked();
+  }
 }
 
 //

src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc

@@ -26,6 +26,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdlib.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
@@ -61,18 +62,7 @@ class RoundRobin : public LoadBalancingPolicy {
   const char* name() const override { return kRoundRobin; }
 
   void UpdateLocked(const grpc_channel_args& args,
-                    grpc_json* lb_config) override;
-  bool PickLocked(PickState* pick, grpc_error** error) override;
-  void CancelPickLocked(PickState* pick, grpc_error* error) override;
-  void CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                 uint32_t initial_metadata_flags_eq,
-                                 grpc_error* error) override;
-  void NotifyOnStateChangeLocked(grpc_connectivity_state* state,
-                                 grpc_closure* closure) override;
-  grpc_connectivity_state CheckConnectivityLocked(
-      grpc_error** connectivity_error) override;
-  void HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) override;
-  void ExitIdleLocked() override;
+                    RefCountedPtr<Config> lb_config) override;
   void ResetBackoffLocked() override;
   void FillChildRefsForChannelz(channelz::ChildRefsList* child_subchannels,
                                 channelz::ChildRefsList* ignored) override;
@@ -117,14 +107,12 @@ class RoundRobin : public LoadBalancingPolicy {
       : public SubchannelList<RoundRobinSubchannelList,
                               RoundRobinSubchannelData> {
    public:
-    RoundRobinSubchannelList(
-        RoundRobin* policy, TraceFlag* tracer,
-        const ServerAddressList& addresses, grpc_combiner* combiner,
-        grpc_client_channel_factory* client_channel_factory,
-        const grpc_channel_args& args)
+    RoundRobinSubchannelList(RoundRobin* policy, TraceFlag* tracer,
+                             const ServerAddressList& addresses,
+                             grpc_combiner* combiner,
+                             const grpc_channel_args& args)
         : SubchannelList(policy, tracer, addresses, combiner,
-                         client_channel_factory, args),
-          last_ready_index_(num_subchannels() - 1) {
+                         policy->channel_control_helper(), args) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -157,15 +145,25 @@ class RoundRobin : public LoadBalancingPolicy {
     // subchannels in each state.
     void UpdateRoundRobinStateFromSubchannelStateCountsLocked();
 
-    size_t GetNextReadySubchannelIndexLocked();
-    void UpdateLastReadySubchannelIndexLocked(size_t last_ready_index);
-
    private:
     size_t num_ready_ = 0;
     size_t num_connecting_ = 0;
     size_t num_transient_failure_ = 0;
     grpc_error* last_transient_failure_error_ = GRPC_ERROR_NONE;
-    size_t last_ready_index_;  // Index into list of last pick.
+  };
+
+  class Picker : public SubchannelPicker {
+   public:
+    Picker(RoundRobin* parent, RoundRobinSubchannelList* subchannel_list);
+
+    PickResult Pick(PickState* pick, grpc_error** error) override;
+
+   private:
+    // Using pointer value only, no ref held -- do not dereference!
+    RoundRobin* parent_;
+
+    size_t last_picked_index_;
+    InlinedVector<RefCountedPtr<ConnectedSubchannel>, 10> subchannels_;
   };
 
   // Helper class to ensure that any function that modifies the child refs
@@ -182,9 +180,6 @@ class RoundRobin : public LoadBalancingPolicy {
 
   void ShutdownLocked() override;
 
-  void StartPickingLocked();
-  bool DoPickLocked(PickState* pick);
-  void DrainPendingPicksLocked();
   void UpdateChildRefsLocked();
 
   /** list of subchannels */
@@ -195,14 +190,8 @@ class RoundRobin : public LoadBalancingPolicy {
    * racing callbacks that reference outdated subchannel lists won't perform any
    * update. */
   OrphanablePtr<RoundRobinSubchannelList> latest_pending_subchannel_list_;
-  /** have we started picking? */
-  bool started_picking_ = false;
   /** are we shutting down? */
   bool shutdown_ = false;
-  /** List of picks that are waiting on connectivity */
-  PickState* pending_picks_ = nullptr;
-  /** our connectivity state tracker */
-  grpc_connectivity_state_tracker state_tracker_;
   /// Lock and data used to capture snapshots of this channel's child
   /// channels and subchannels. This data is consumed by channelz.
   gpr_mu child_refs_mu_;
@@ -210,15 +199,56 @@ class RoundRobin : public LoadBalancingPolicy {
   channelz::ChildRefsList child_channels_;
 };
 
+//
+// RoundRobin::Picker
+//
+
+RoundRobin::Picker::Picker(RoundRobin* parent,
+                           RoundRobinSubchannelList* subchannel_list)
+    : parent_(parent) {
+  for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
+    auto* connected_subchannel =
+        subchannel_list->subchannel(i)->connected_subchannel();
+    if (connected_subchannel != nullptr) {
+      subchannels_.push_back(connected_subchannel->Ref());
+    }
+  }
+  // For discussion on why we generate a random starting index for
+  // the picker, see https://github.com/grpc/grpc-go/issues/2580.
+  // TODO(roth): rand(3) is not thread-safe.  This should be replaced with
+  // something better as part of https://github.com/grpc/grpc/issues/17891.
+  last_picked_index_ = rand() % subchannels_.size();
+  if (grpc_lb_round_robin_trace.enabled()) {
+    gpr_log(GPR_INFO,
+            "[RR %p picker %p] created picker from subchannel_list=%p "
+            "with %" PRIuPTR " READY subchannels; last_picked_index_=%" PRIuPTR,
+            parent_, this, subchannel_list, subchannels_.size(),
+            last_picked_index_);
+  }
+}
+
+RoundRobin::Picker::PickResult RoundRobin::Picker::Pick(PickState* pick,
+                                                        grpc_error** error) {
+  last_picked_index_ = (last_picked_index_ + 1) % subchannels_.size();
+  if (grpc_lb_round_robin_trace.enabled()) {
+    gpr_log(GPR_INFO,
+            "[RR %p picker %p] returning index %" PRIuPTR
+            ", connected_subchannel=%p",
+            parent_, this, last_picked_index_,
+            subchannels_[last_picked_index_].get());
+  }
+  pick->connected_subchannel = subchannels_[last_picked_index_];
+  return PICK_COMPLETE;
+}
+
+//
+// RoundRobin
+//
+
 RoundRobin::RoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
-  GPR_ASSERT(args.client_channel_factory != nullptr);
   gpr_mu_init(&child_refs_mu_);
-  grpc_connectivity_state_init(&state_tracker_, GRPC_CHANNEL_IDLE,
-                               "round_robin");
-  UpdateLocked(*args.args, args.lb_config);
   if (grpc_lb_round_robin_trace.enabled()) {
-    gpr_log(GPR_INFO, "[RR %p] Created with %" PRIuPTR " subchannels", this,
-            subchannel_list_->num_subchannels());
+    gpr_log(GPR_INFO, "[RR %p] Created", this);
   }
 }
 
@@ -229,93 +259,16 @@ RoundRobin::~RoundRobin() {
   gpr_mu_destroy(&child_refs_mu_);
   GPR_ASSERT(subchannel_list_ == nullptr);
   GPR_ASSERT(latest_pending_subchannel_list_ == nullptr);
-  GPR_ASSERT(pending_picks_ == nullptr);
-  grpc_connectivity_state_destroy(&state_tracker_);
-}
-
-void RoundRobin::HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) {
-  PickState* pick;
-  while ((pick = pending_picks_) != nullptr) {
-    pending_picks_ = pick->next;
-    grpc_error* error = GRPC_ERROR_NONE;
-    if (new_policy->PickLocked(pick, &error)) {
-      // Synchronous return, schedule closure.
-      GRPC_CLOSURE_SCHED(pick->on_complete, error);
-    }
-  }
 }
 
 void RoundRobin::ShutdownLocked() {
   AutoChildRefsUpdater guard(this);
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel shutdown");
   if (grpc_lb_round_robin_trace.enabled()) {
     gpr_log(GPR_INFO, "[RR %p] Shutting down", this);
   }
   shutdown_ = true;
-  PickState* pick;
-  while ((pick = pending_picks_) != nullptr) {
-    pending_picks_ = pick->next;
-    pick->connected_subchannel.reset();
-    GRPC_CLOSURE_SCHED(pick->on_complete, GRPC_ERROR_REF(error));
-  }
-  grpc_connectivity_state_set(&state_tracker_, GRPC_CHANNEL_SHUTDOWN,
-                              GRPC_ERROR_REF(error), "rr_shutdown");
   subchannel_list_.reset();
   latest_pending_subchannel_list_.reset();
-  TryReresolutionLocked(&grpc_lb_round_robin_trace, GRPC_ERROR_CANCELLED);
-  GRPC_ERROR_UNREF(error);
-}
-
-void RoundRobin::CancelPickLocked(PickState* pick, grpc_error* error) {
-  PickState* pp = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pp != nullptr) {
-    PickState* next = pp->next;
-    if (pp == pick) {
-      pick->connected_subchannel.reset();
-      GRPC_CLOSURE_SCHED(pick->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pp->next = pending_picks_;
-      pending_picks_ = pp;
-    }
-    pp = next;
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void RoundRobin::CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                           uint32_t initial_metadata_flags_eq,
-                                           grpc_error* error) {
-  PickState* pick = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pick != nullptr) {
-    PickState* next = pick->next;
-    if ((*pick->initial_metadata_flags & initial_metadata_flags_mask) ==
-        initial_metadata_flags_eq) {
-      pick->connected_subchannel.reset();
-      GRPC_CLOSURE_SCHED(pick->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pick->next = pending_picks_;
-      pending_picks_ = pick;
-    }
-    pick = next;
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void RoundRobin::StartPickingLocked() {
-  started_picking_ = true;
-  subchannel_list_->StartWatchingLocked();
-}
-
-void RoundRobin::ExitIdleLocked() {
-  if (!started_picking_) {
-    StartPickingLocked();
-  }
 }
 
 void RoundRobin::ResetBackoffLocked() {
@@ -325,60 +278,6 @@ void RoundRobin::ResetBackoffLocked() {
   }
 }
 
-bool RoundRobin::DoPickLocked(PickState* pick) {
-  const size_t next_ready_index =
-      subchannel_list_->GetNextReadySubchannelIndexLocked();
-  if (next_ready_index < subchannel_list_->num_subchannels()) {
-    /* readily available, report right away */
-    RoundRobinSubchannelData* sd =
-        subchannel_list_->subchannel(next_ready_index);
-    GPR_ASSERT(sd->connected_subchannel() != nullptr);
-    pick->connected_subchannel = sd->connected_subchannel()->Ref();
-    if (grpc_lb_round_robin_trace.enabled()) {
-      gpr_log(GPR_INFO,
-              "[RR %p] Picked target <-- Subchannel %p (connected %p) (sl %p, "
-              "index %" PRIuPTR ")",
-              this, sd->subchannel(), pick->connected_subchannel.get(),
-              sd->subchannel_list(), next_ready_index);
-    }
-    /* only advance the last picked pointer if the selection was used */
-    subchannel_list_->UpdateLastReadySubchannelIndexLocked(next_ready_index);
-    return true;
-  }
-  return false;
-}
-
-void RoundRobin::DrainPendingPicksLocked() {
-  PickState* pick;
-  while ((pick = pending_picks_)) {
-    pending_picks_ = pick->next;
-    GPR_ASSERT(DoPickLocked(pick));
-    GRPC_CLOSURE_SCHED(pick->on_complete, GRPC_ERROR_NONE);
-  }
-}
-
-bool RoundRobin::PickLocked(PickState* pick, grpc_error** error) {
-  if (grpc_lb_round_robin_trace.enabled()) {
-    gpr_log(GPR_INFO, "[RR %p] Trying to pick (shutdown: %d)", this, shutdown_);
-  }
-  GPR_ASSERT(!shutdown_);
-  if (subchannel_list_ != nullptr) {
-    if (DoPickLocked(pick)) return true;
-  }
-  if (pick->on_complete == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No pick result available but synchronous result required.");
-    return true;
-  }
-  /* no pick currently available. Save for later in list of pending picks */
-  pick->next = pending_picks_;
-  pending_picks_ = pick;
-  if (!started_picking_) {
-    StartPickingLocked();
-  }
-  return false;
-}
-
 void RoundRobin::FillChildRefsForChannelz(
     channelz::ChildRefsList* child_subchannels_to_fill,
     channelz::ChildRefsList* ignored) {
@@ -426,14 +325,14 @@ void RoundRobin::RoundRobinSubchannelList::StartWatchingLocked() {
       subchannel(i)->UpdateConnectivityStateLocked(state, error);
     }
   }
-  // Now set the LB policy's state based on the subchannels' states.
-  UpdateRoundRobinStateFromSubchannelStateCountsLocked();
   // Start connectivity watch for each subchannel.
   for (size_t i = 0; i < num_subchannels(); i++) {
     if (subchannel(i)->subchannel() != nullptr) {
       subchannel(i)->StartConnectivityWatchLocked();
     }
   }
+  // Now set the LB policy's state based on the subchannels' states.
+  UpdateRoundRobinStateFromSubchannelStateCountsLocked();
 }
 
 void RoundRobin::RoundRobinSubchannelList::UpdateStateCountersLocked(
@@ -462,8 +361,8 @@ void RoundRobin::RoundRobinSubchannelList::UpdateStateCountersLocked(
   last_transient_failure_error_ = transient_failure_error;
 }
 
-// Sets the RR policy's connectivity state based on the current
-// subchannel list.
+// Sets the RR policy's connectivity state and generates a new picker based
+// on the current subchannel list.
 void RoundRobin::RoundRobinSubchannelList::
     MaybeUpdateRoundRobinConnectivityStateLocked() {
   RoundRobin* p = static_cast<RoundRobin*>(policy());
@@ -485,18 +384,21 @@ void RoundRobin::RoundRobinSubchannelList::
    */
   if (num_ready_ > 0) {
     /* 1) READY */
-    grpc_connectivity_state_set(&p->state_tracker_, GRPC_CHANNEL_READY,
-                                GRPC_ERROR_NONE, "rr_ready");
+    p->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_READY, GRPC_ERROR_NONE,
+        UniquePtr<SubchannelPicker>(New<Picker>(p, this)));
   } else if (num_connecting_ > 0) {
     /* 2) CONNECTING */
-    grpc_connectivity_state_set(&p->state_tracker_, GRPC_CHANNEL_CONNECTING,
-                                GRPC_ERROR_NONE, "rr_connecting");
+    p->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE,
+        UniquePtr<SubchannelPicker>(New<QueuePicker>(p->Ref())));
   } else if (num_transient_failure_ == num_subchannels()) {
     /* 3) TRANSIENT_FAILURE */
-    grpc_connectivity_state_set(&p->state_tracker_,
-                                GRPC_CHANNEL_TRANSIENT_FAILURE,
-                                GRPC_ERROR_REF(last_transient_failure_error_),
-                                "rr_exhausted_subchannels");
+    p->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        GRPC_ERROR_REF(last_transient_failure_error_),
+        UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(
+            GRPC_ERROR_REF(last_transient_failure_error_))));
   }
 }
 
@@ -525,8 +427,6 @@ void RoundRobin::RoundRobinSubchannelList::
       }
       p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
     }
-    // Drain pending picks.
-    p->DrainPendingPicksLocked();
   }
   // Update the RR policy's connectivity state if needed.
   MaybeUpdateRoundRobinConnectivityStateLocked();
@@ -566,84 +466,18 @@ void RoundRobin::RoundRobinSubchannelData::ProcessConnectivityChangeLocked(
               "Requesting re-resolution",
               p, subchannel());
     }
-    p->TryReresolutionLocked(&grpc_lb_round_robin_trace, GRPC_ERROR_NONE);
+    p->channel_control_helper()->RequestReresolution();
   }
+  // Renew connectivity watch.
+  RenewConnectivityWatchLocked();
   // Update state counters.
   UpdateConnectivityStateLocked(connectivity_state, error);
   // Update overall state and renew notification.
   subchannel_list()->UpdateRoundRobinStateFromSubchannelStateCountsLocked();
-  RenewConnectivityWatchLocked();
-}
-
-/** Returns the index into p->subchannel_list->subchannels of the next
- * subchannel in READY state, or p->subchannel_list->num_subchannels if no
- * subchannel is READY.
- *
- * Note that this function does *not* update p->last_ready_subchannel_index.
- * The caller must do that if it returns a pick. */
-size_t
-RoundRobin::RoundRobinSubchannelList::GetNextReadySubchannelIndexLocked() {
-  if (grpc_lb_round_robin_trace.enabled()) {
-    gpr_log(GPR_INFO,
-            "[RR %p] getting next ready subchannel (out of %" PRIuPTR
-            "), last_ready_index=%" PRIuPTR,
-            policy(), num_subchannels(), last_ready_index_);
-  }
-  for (size_t i = 0; i < num_subchannels(); ++i) {
-    const size_t index = (i + last_ready_index_ + 1) % num_subchannels();
-    if (grpc_lb_round_robin_trace.enabled()) {
-      gpr_log(
-          GPR_INFO,
-          "[RR %p] checking subchannel %p, subchannel_list %p, index %" PRIuPTR
-          ": state=%s",
-          policy(), subchannel(index)->subchannel(), this, index,
-          grpc_connectivity_state_name(
-              subchannel(index)->connectivity_state()));
-    }
-    if (subchannel(index)->connectivity_state() == GRPC_CHANNEL_READY) {
-      if (grpc_lb_round_robin_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "[RR %p] found next ready subchannel (%p) at index %" PRIuPTR
-                " of subchannel_list %p",
-                policy(), subchannel(index)->subchannel(), index, this);
-      }
-      return index;
-    }
-  }
-  if (grpc_lb_round_robin_trace.enabled()) {
-    gpr_log(GPR_INFO, "[RR %p] no subchannels in ready state", this);
-  }
-  return num_subchannels();
-}
-
-// Sets last_ready_index_ to last_ready_index.
-void RoundRobin::RoundRobinSubchannelList::UpdateLastReadySubchannelIndexLocked(
-    size_t last_ready_index) {
-  GPR_ASSERT(last_ready_index < num_subchannels());
-  last_ready_index_ = last_ready_index;
-  if (grpc_lb_round_robin_trace.enabled()) {
-    gpr_log(GPR_INFO,
-            "[RR %p] setting last_ready_subchannel_index=%" PRIuPTR
-            " (SC %p, CSC %p)",
-            policy(), last_ready_index,
-            subchannel(last_ready_index)->subchannel(),
-            subchannel(last_ready_index)->connected_subchannel());
-  }
-}
-
-grpc_connectivity_state RoundRobin::CheckConnectivityLocked(
-    grpc_error** error) {
-  return grpc_connectivity_state_get(&state_tracker_, error);
-}
-
-void RoundRobin::NotifyOnStateChangeLocked(grpc_connectivity_state* current,
-                                           grpc_closure* notify) {
-  grpc_connectivity_state_notify_on_state_change(&state_tracker_, current,
-                                                 notify);
 }
 
 void RoundRobin::UpdateLocked(const grpc_channel_args& args,
-                              grpc_json* lb_config) {
+                              RefCountedPtr<Config> lb_config) {
   AutoChildRefsUpdater guard(this);
   const ServerAddressList* addresses = FindServerAddressListChannelArg(&args);
   if (addresses == nullptr) {
@@ -651,10 +485,11 @@ void RoundRobin::UpdateLocked(const grpc_channel_args& args,
     // If we don't have a current subchannel list, go into TRANSIENT_FAILURE.
     // Otherwise, keep using the current subchannel list (ignore this update).
     if (subchannel_list_ == nullptr) {
-      grpc_connectivity_state_set(
-          &state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing update in args"),
-          "rr_update_missing");
+      grpc_error* error =
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing update in args");
+      channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(error),
+          UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(error)));
     }
     return;
   }
@@ -671,21 +506,23 @@ void RoundRobin::UpdateLocked(const grpc_channel_args& args,
     }
   }
   latest_pending_subchannel_list_ = MakeOrphanable<RoundRobinSubchannelList>(
-      this, &grpc_lb_round_robin_trace, *addresses, combiner(),
-      client_channel_factory(), args);
-  // If we haven't started picking yet or the new list is empty,
-  // immediately promote the new list to the current list.
-  if (!started_picking_ ||
-      latest_pending_subchannel_list_->num_subchannels() == 0) {
-    if (latest_pending_subchannel_list_->num_subchannels() == 0) {
-      grpc_connectivity_state_set(
-          &state_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update"),
-          "rr_update_empty");
-    }
+      this, &grpc_lb_round_robin_trace, *addresses, combiner(), args);
+  if (latest_pending_subchannel_list_->num_subchannels() == 0) {
+    // If the new list is empty, immediately promote the new list to the
+    // current list and transition to TRANSIENT_FAILURE.
+    grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update");
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(error),
+        UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(error)));
+    subchannel_list_ = std::move(latest_pending_subchannel_list_);
+  } else if (subchannel_list_ == nullptr) {
+    // If there is no current list, immediately promote the new list to
+    // the current list and start watching it.
     subchannel_list_ = std::move(latest_pending_subchannel_list_);
+    subchannel_list_->StartWatchingLocked();
   } else {
-    // If we've started picking, start watching the new list.
+    // Start watching the pending list.  It will get swapped into the
+    // current list when it reports READY.
     latest_pending_subchannel_list_->StartWatchingLocked();
   }
 }

src/core/ext/filters/client_channel/lb_policy/subchannel_list.h

@@ -232,7 +232,7 @@ class SubchannelList : public InternallyRefCounted<SubchannelListType> {
  protected:
   SubchannelList(LoadBalancingPolicy* policy, TraceFlag* tracer,
                  const ServerAddressList& addresses, grpc_combiner* combiner,
-                 grpc_client_channel_factory* client_channel_factory,
+                 LoadBalancingPolicy::ChannelControlHelper* helper,
                  const grpc_channel_args& args);
 
   virtual ~SubchannelList();
@@ -486,7 +486,7 @@ template <typename SubchannelListType, typename SubchannelDataType>
 SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
     LoadBalancingPolicy* policy, TraceFlag* tracer,
     const ServerAddressList& addresses, grpc_combiner* combiner,
-    grpc_client_channel_factory* client_channel_factory,
+    LoadBalancingPolicy::ChannelControlHelper* helper,
     const grpc_channel_args& args)
     : InternallyRefCounted<SubchannelListType>(tracer),
       policy_(policy),
@@ -509,12 +509,8 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
                                          GRPC_ARG_INHIBIT_HEALTH_CHECKING};
   // Create a subchannel for each address.
   for (size_t i = 0; i < addresses.size(); i++) {
-    // If there were any balancer addresses, we would have chosen grpclb
-    // policy, which does not use a SubchannelList.
     GPR_ASSERT(!addresses[i].IsBalancer());
-    InlinedVector<grpc_arg, 4> args_to_add;
-    args_to_add.emplace_back(
-        SubchannelPoolInterface::CreateChannelArg(policy_->subchannel_pool()));
+    InlinedVector<grpc_arg, 3> args_to_add;
     const size_t subchannel_address_arg_index = args_to_add.size();
     args_to_add.emplace_back(
         Subchannel::CreateSubchannelAddressArg(&addresses[i].address()));
@@ -527,8 +523,7 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
         &args, keys_to_remove, GPR_ARRAY_SIZE(keys_to_remove),
         args_to_add.data(), args_to_add.size());
     gpr_free(args_to_add[subchannel_address_arg_index].value.string);
-    Subchannel* subchannel = grpc_client_channel_factory_create_subchannel(
-        client_channel_factory, new_args);
+    Subchannel* subchannel = helper->CreateSubchannel(*new_args);
     grpc_channel_args_destroy(new_args);
     if (subchannel == nullptr) {
       // Subchannel could not be created.

src/core/ext/filters/client_channel/lb_policy/xds/xds.cc

@@ -26,14 +26,13 @@
 /// channel that uses pick_first to select from the list of balancer
 /// addresses.
 ///
-/// The first time the xDS policy gets a request for a pick or to exit the idle
-/// state, \a StartPickingLocked() is called. This method is responsible for
-/// instantiating the internal *streaming* call to the LB server (whichever
-/// address pick_first chose). The call will be complete when either the
-/// balancer sends status or when we cancel the call (e.g., because we are
-/// shutting down). In needed, we retry the call. If we received at least one
-/// valid message from the server, a new call attempt will be made immediately;
-/// otherwise, we apply back-off delays between attempts.
+/// When we get our initial update, we instantiate the internal *streaming*
+/// call to the LB server (whichever address pick_first chose). The call
+/// will be complete when either the balancer sends status or when we cancel
+/// the call (e.g., because we are shutting down). In needed, we retry the
+/// call. If we received at least one valid message from the server, a new
+/// call attempt will be made immediately; otherwise, we apply back-off
+/// delays between attempts.
 ///
 /// We maintain an internal child policy (round_robin) instance for distributing
 /// requests across backends.  Whenever we receive a new serverlist from
@@ -70,7 +69,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_client_stats.h"
@@ -124,49 +122,13 @@ class XdsLb : public LoadBalancingPolicy {
   const char* name() const override { return kXds; }
 
   void UpdateLocked(const grpc_channel_args& args,
-                    grpc_json* lb_config) override;
-  bool PickLocked(PickState* pick, grpc_error** error) override;
-  void CancelPickLocked(PickState* pick, grpc_error* error) override;
-  void CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                 uint32_t initial_metadata_flags_eq,
-                                 grpc_error* error) override;
-  void NotifyOnStateChangeLocked(grpc_connectivity_state* state,
-                                 grpc_closure* closure) override;
-  grpc_connectivity_state CheckConnectivityLocked(
-      grpc_error** connectivity_error) override;
-  void HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) override;
-  void ExitIdleLocked() override;
+                    RefCountedPtr<Config> lb_config) override;
   void ResetBackoffLocked() override;
   void FillChildRefsForChannelz(
       channelz::ChildRefsList* child_subchannels,
       channelz::ChildRefsList* child_channels) override;
 
  private:
-  /// Linked list of pending pick requests. It stores all information needed to
-  /// eventually call pick() on them. They mainly stay pending waiting for the
-  /// child policy to be created.
-  ///
-  /// Note that when a pick is sent to the child policy, we inject our own
-  /// on_complete callback, so that we can intercept the result before
-  /// invoking the original on_complete callback.  This allows us to set the
-  /// LB token metadata and add client_stats to the call context.
-  /// See \a pending_pick_complete() for details.
-  struct PendingPick {
-    // The xds lb instance that created the wrapping. This instance is not
-    // owned; reference counts are untouched. It's used only for logging
-    // purposes.
-    XdsLb* xdslb_policy;
-    // The original pick.
-    PickState* pick;
-    // Our on_complete closure and the original one.
-    grpc_closure on_complete;
-    grpc_closure* original_on_complete;
-    // Stats for client-side load reporting.
-    RefCountedPtr<XdsLbClientStats> client_stats;
-    // Next pending pick.
-    PendingPick* next = nullptr;
-  };
-
   /// Contains a call to the LB server and all the data related to the call.
   class BalancerCallState : public InternallyRefCounted<BalancerCallState> {
    public:
@@ -241,21 +203,50 @@ class XdsLb : public LoadBalancingPolicy {
     grpc_closure client_load_report_closure_;
   };
 
+  class Picker : public SubchannelPicker {
+   public:
+    Picker(UniquePtr<SubchannelPicker> child_picker,
+           RefCountedPtr<XdsLbClientStats> client_stats)
+        : child_picker_(std::move(child_picker)),
+          client_stats_(std::move(client_stats)) {}
+
+    PickResult Pick(PickState* pick, grpc_error** error) override;
+
+   private:
+    UniquePtr<SubchannelPicker> child_picker_;
+    RefCountedPtr<XdsLbClientStats> client_stats_;
+  };
+
+  class Helper : public ChannelControlHelper {
+   public:
+    explicit Helper(RefCountedPtr<XdsLb> parent) : parent_(std::move(parent)) {}
+
+    Subchannel* CreateSubchannel(const grpc_channel_args& args) override;
+    grpc_channel* CreateChannel(const char* target,
+                                grpc_client_channel_type type,
+                                const grpc_channel_args& args) override;
+    void UpdateState(grpc_connectivity_state state, grpc_error* state_error,
+                     UniquePtr<SubchannelPicker> picker) override;
+    void RequestReresolution() override;
+
+   private:
+    RefCountedPtr<XdsLb> parent_;
+  };
+
   ~XdsLb();
 
   void ShutdownLocked() override;
 
-  // Helper function used in ctor and UpdateLocked().
+  // Helper function used in UpdateLocked().
   void ProcessChannelArgsLocked(const grpc_channel_args& args);
 
   // Parses the xds config given the JSON node of the first child of XdsConfig.
   // If parsing succeeds, updates \a balancer_name, and updates \a
-  // child_policy_json_dump_ and \a fallback_policy_json_dump_ if they are also
+  // child_policy_config_ and \a fallback_policy_config_ if they are also
   // found. Does nothing upon failure.
-  void ParseLbConfig(grpc_json* xds_config_json);
+  void ParseLbConfig(Config* xds_config);
 
   // Methods for dealing with the balancer channel and call.
-  void StartPickingLocked();
   void StartBalancerCallLocked();
   static void OnFallbackTimerLocked(void* arg, grpc_error* error);
   void StartBalancerCallRetryTimerLocked();
@@ -263,24 +254,10 @@ class XdsLb : public LoadBalancingPolicy {
   static void OnBalancerChannelConnectivityChangedLocked(void* arg,
                                                          grpc_error* error);
 
-  // Pending pick methods.
-  static void PendingPickCleanup(PendingPick* pp);
-  PendingPick* PendingPickCreate(PickState* pick);
-  void AddPendingPick(PendingPick* pp);
-  static void OnPendingPickComplete(void* arg, grpc_error* error);
-
   // Methods for dealing with the child policy.
   void CreateOrUpdateChildPolicyLocked();
   grpc_channel_args* CreateChildPolicyArgsLocked();
   void CreateChildPolicyLocked(const char* name, Args args);
-  bool PickFromChildPolicyLocked(bool force_async, PendingPick* pp,
-                                 grpc_error** error);
-  void UpdateConnectivityStateFromChildPolicyLocked(
-      grpc_error* child_state_error);
-  static void OnChildPolicyConnectivityChangedLocked(void* arg,
-                                                     grpc_error* error);
-  static void OnChildPolicyRequestReresolutionLocked(void* arg,
-                                                     grpc_error* error);
 
   // Who the client is trying to communicate with.
   const char* server_name_ = nullptr;
@@ -292,9 +269,7 @@ class XdsLb : public LoadBalancingPolicy {
   grpc_channel_args* args_ = nullptr;
 
   // Internal state.
-  bool started_picking_ = false;
   bool shutting_down_ = false;
-  grpc_connectivity_state_tracker state_tracker_;
 
   // The channel for communicating with the LB server.
   grpc_channel* lb_channel_ = nullptr;
@@ -328,7 +303,8 @@ class XdsLb : public LoadBalancingPolicy {
 
   // Timeout in milliseconds for before using fallback backend addresses.
   // 0 means not using fallback.
-  UniquePtr<char> fallback_policy_json_string_;
+  UniquePtr<char> fallback_policy_name_;
+  RefCountedPtr<Config> fallback_policy_config_;
   int lb_fallback_timeout_ms_ = 0;
   // The backend addresses from the resolver.
   UniquePtr<ServerAddressList> fallback_backend_addresses_;
@@ -337,17 +313,92 @@ class XdsLb : public LoadBalancingPolicy {
   grpc_timer lb_fallback_timer_;
   grpc_closure lb_on_fallback_;
 
-  // Pending picks that are waiting on the xDS policy's connectivity.
-  PendingPick* pending_picks_ = nullptr;
-
   // The policy to use for the backends.
+  UniquePtr<char> child_policy_name_;
+  RefCountedPtr<Config> child_policy_config_;
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
-  UniquePtr<char> child_policy_json_string_;
-  grpc_connectivity_state child_connectivity_state_;
-  grpc_closure on_child_connectivity_changed_;
-  grpc_closure on_child_request_reresolution_;
 };
 
+//
+// XdsLb::Picker
+//
+
+// Destroy function used when embedding client stats in call context.
+void DestroyClientStats(void* arg) {
+  static_cast<XdsLbClientStats*>(arg)->Unref();
+}
+
+XdsLb::Picker::PickResult XdsLb::Picker::Pick(PickState* pick,
+                                              grpc_error** error) {
+  // TODO(roth): Add support for drop handling.
+  // Forward pick to child policy.
+  PickResult result = child_picker_->Pick(pick, error);
+  // If pick succeeded, add client stats.
+  if (result == PickResult::PICK_COMPLETE &&
+      pick->connected_subchannel != nullptr && client_stats_ != nullptr) {
+    pick->subchannel_call_context[GRPC_GRPCLB_CLIENT_STATS].value =
+        client_stats_->Ref().release();
+    pick->subchannel_call_context[GRPC_GRPCLB_CLIENT_STATS].destroy =
+        DestroyClientStats;
+  }
+  return result;
+}
+
+//
+// XdsLb::Helper
+//
+
+Subchannel* XdsLb::Helper::CreateSubchannel(const grpc_channel_args& args) {
+  if (parent_->shutting_down_) return nullptr;
+  return parent_->channel_control_helper()->CreateSubchannel(args);
+}
+
+grpc_channel* XdsLb::Helper::CreateChannel(const char* target,
+                                           grpc_client_channel_type type,
+                                           const grpc_channel_args& args) {
+  if (parent_->shutting_down_) return nullptr;
+  return parent_->channel_control_helper()->CreateChannel(target, type, args);
+}
+
+void XdsLb::Helper::UpdateState(grpc_connectivity_state state,
+                                grpc_error* state_error,
+                                UniquePtr<SubchannelPicker> picker) {
+  if (parent_->shutting_down_) {
+    GRPC_ERROR_UNREF(state_error);
+    return;
+  }
+  // TODO(juanlishen): When in fallback mode, pass the child picker
+  // through without wrapping it.  (Or maybe use a different helper for
+  // the fallback policy?)
+  RefCountedPtr<XdsLbClientStats> client_stats;
+  if (parent_->lb_calld_ != nullptr &&
+      parent_->lb_calld_->client_stats() != nullptr) {
+    client_stats = parent_->lb_calld_->client_stats()->Ref();
+  }
+  parent_->channel_control_helper()->UpdateState(
+      state, state_error,
+      UniquePtr<SubchannelPicker>(
+          New<Picker>(std::move(picker), std::move(client_stats))));
+}
+
+void XdsLb::Helper::RequestReresolution() {
+  if (parent_->shutting_down_) return;
+  if (grpc_lb_xds_trace.enabled()) {
+    gpr_log(GPR_INFO,
+            "[xdslb %p] Re-resolution requested from the internal RR policy "
+            "(%p).",
+            parent_.get(), parent_->child_policy_.get());
+  }
+  // If we are talking to a balancer, we expect to get updated addresses
+  // from the balancer, so we can ignore the re-resolution request from
+  // the RR policy. Otherwise, pass the re-resolution request up to the
+  // channel.
+  if (parent_->lb_calld_ == nullptr ||
+      !parent_->lb_calld_->seen_initial_response()) {
+    parent_->channel_control_helper()->RequestReresolution();
+  }
+}
+
 //
 // serverlist parsing code
 //
@@ -709,7 +760,7 @@ void XdsLb::BalancerCallState::OnBalancerMessageReceivedLocked(
       // serverlist returned from the current LB call.
       if (lb_calld->client_stats_report_interval_ > 0 &&
           lb_calld->client_stats_ == nullptr) {
-        lb_calld->client_stats_.reset(New<XdsLbClientStats>());
+        lb_calld->client_stats_ = MakeRefCounted<XdsLbClientStats>();
         // TODO(roth): We currently track this ref manually.  Once the
         // ClosureRef API is ready, we should pass the RefCountedPtr<> along
         // with the callback.
@@ -792,13 +843,13 @@ void XdsLb::BalancerCallState::OnBalancerStatusReceivedLocked(
             lb_calld->lb_call_, grpc_error_string(error));
     gpr_free(status_details);
   }
-  xdslb_policy->TryReresolutionLocked(&grpc_lb_xds_trace, GRPC_ERROR_NONE);
   // If this lb_calld is still in use, this call ended because of a failure so
   // we want to retry connecting. Otherwise, we have deliberately ended this
   // call and no further action is required.
   if (lb_calld == xdslb_policy->lb_calld_.get()) {
     xdslb_policy->lb_calld_.reset();
     GPR_ASSERT(!xdslb_policy->shutting_down_);
+    xdslb_policy->channel_control_helper()->RequestReresolution();
     if (lb_calld->seen_initial_response_) {
       // If we lose connection to the LB server, reset the backoff and restart
       // the LB call immediately.
@@ -903,8 +954,7 @@ grpc_channel_args* BuildBalancerChannelArgs(
 // ctor and dtor
 //
 
-// TODO(vishalpowar): Use lb_config in args to configure LB policy.
-XdsLb::XdsLb(LoadBalancingPolicy::Args args)
+XdsLb::XdsLb(Args args)
     : LoadBalancingPolicy(std::move(args)),
       response_generator_(MakeRefCounted<FakeResolverResponseGenerator>()),
       lb_call_backoff_(
@@ -919,13 +969,6 @@ XdsLb::XdsLb(LoadBalancingPolicy::Args args)
   GRPC_CLOSURE_INIT(&lb_channel_on_connectivity_changed_,
                     &XdsLb::OnBalancerChannelConnectivityChangedLocked, this,
                     grpc_combiner_scheduler(args.combiner));
-  GRPC_CLOSURE_INIT(&on_child_connectivity_changed_,
-                    &XdsLb::OnChildPolicyConnectivityChangedLocked, this,
-                    grpc_combiner_scheduler(args.combiner));
-  GRPC_CLOSURE_INIT(&on_child_request_reresolution_,
-                    &XdsLb::OnChildPolicyRequestReresolutionLocked, this,
-                    grpc_combiner_scheduler(args.combiner));
-  grpc_connectivity_state_init(&state_tracker_, GRPC_CHANNEL_IDLE, "xds");
   // Record server name.
   const grpc_arg* arg = grpc_channel_args_find(args.args, GRPC_ARG_SERVER_URI);
   const char* server_uri = grpc_channel_arg_get_string(arg);
@@ -946,25 +989,18 @@ XdsLb::XdsLb(LoadBalancingPolicy::Args args)
   arg = grpc_channel_args_find(args.args, GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS);
   lb_fallback_timeout_ms_ = grpc_channel_arg_get_integer(
       arg, {GRPC_XDS_DEFAULT_FALLBACK_TIMEOUT_MS, 0, INT_MAX});
-  // Parse the LB config.
-  ParseLbConfig(args.lb_config);
-  // Process channel args.
-  ProcessChannelArgsLocked(*args.args);
 }
 
 XdsLb::~XdsLb() {
-  GPR_ASSERT(pending_picks_ == nullptr);
   gpr_mu_destroy(&lb_channel_mu_);
   gpr_free((void*)server_name_);
   grpc_channel_args_destroy(args_);
-  grpc_connectivity_state_destroy(&state_tracker_);
   if (serverlist_ != nullptr) {
     xds_grpclb_destroy_serverlist(serverlist_);
   }
 }
 
 void XdsLb::ShutdownLocked() {
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel shutdown");
   shutting_down_ = true;
   lb_calld_.reset();
   if (retry_timer_callback_pending_) {
@@ -974,7 +1010,6 @@ void XdsLb::ShutdownLocked() {
     grpc_timer_cancel(&lb_fallback_timer_);
   }
   child_policy_.reset();
-  TryReresolutionLocked(&grpc_lb_xds_trace, GRPC_ERROR_CANCELLED);
   // We destroy the LB channel here instead of in our destructor because
   // destroying the channel triggers a last callback to
   // OnBalancerChannelConnectivityChangedLocked(), and we need to be
@@ -985,115 +1020,12 @@ void XdsLb::ShutdownLocked() {
     lb_channel_ = nullptr;
     gpr_mu_unlock(&lb_channel_mu_);
   }
-  grpc_connectivity_state_set(&state_tracker_, GRPC_CHANNEL_SHUTDOWN,
-                              GRPC_ERROR_REF(error), "xds_shutdown");
-  // Clear pending picks.
-  PendingPick* pp;
-  while ((pp = pending_picks_) != nullptr) {
-    pending_picks_ = pp->next;
-    pp->pick->connected_subchannel.reset();
-    // Note: pp is deleted in this callback.
-    GRPC_CLOSURE_SCHED(&pp->on_complete, GRPC_ERROR_REF(error));
-  }
-  GRPC_ERROR_UNREF(error);
 }
 
 //
 // public methods
 //
 
-void XdsLb::HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) {
-  PendingPick* pp;
-  while ((pp = pending_picks_) != nullptr) {
-    pending_picks_ = pp->next;
-    pp->pick->on_complete = pp->original_on_complete;
-    grpc_error* error = GRPC_ERROR_NONE;
-    if (new_policy->PickLocked(pp->pick, &error)) {
-      // Synchronous return; schedule closure.
-      GRPC_CLOSURE_SCHED(pp->pick->on_complete, error);
-    }
-    Delete(pp);
-  }
-}
-
-// Cancel a specific pending pick.
-//
-// A pick progresses as follows:
-// - If there's a child policy available, it'll be handed over to child policy
-//   (in CreateChildPolicyLocked()). From that point onwards, it'll be the
-//   child policy's responsibility. For cancellations, that implies the pick
-//   needs to be also cancelled by the child policy instance.
-// - Otherwise, without a child policy instance, picks stay pending at this
-//   policy's level (xds), inside the pending_picks_ list. To cancel these,
-//   we invoke the completion closure and set the pick's connected
-//   subchannel to nullptr right here.
-void XdsLb::CancelPickLocked(PickState* pick, grpc_error* error) {
-  PendingPick* pp = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pp != nullptr) {
-    PendingPick* next = pp->next;
-    if (pp->pick == pick) {
-      pick->connected_subchannel.reset();
-      // Note: pp is deleted in this callback.
-      GRPC_CLOSURE_SCHED(&pp->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pp->next = pending_picks_;
-      pending_picks_ = pp;
-    }
-    pp = next;
-  }
-  if (child_policy_ != nullptr) {
-    child_policy_->CancelPickLocked(pick, GRPC_ERROR_REF(error));
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-// Cancel all pending picks.
-//
-// A pick progresses as follows:
-// - If there's a child policy available, it'll be handed over to child policy
-//   (in CreateChildPolicyLocked()). From that point onwards, it'll be the
-//   child policy's responsibility. For cancellations, that implies the pick
-//   needs to be also cancelled by the child policy instance.
-// - Otherwise, without a child policy instance, picks stay pending at this
-//   policy's level (xds), inside the pending_picks_ list. To cancel these,
-//   we invoke the completion closure and set the pick's connected
-//   subchannel to nullptr right here.
-void XdsLb::CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                      uint32_t initial_metadata_flags_eq,
-                                      grpc_error* error) {
-  PendingPick* pp = pending_picks_;
-  pending_picks_ = nullptr;
-  while (pp != nullptr) {
-    PendingPick* next = pp->next;
-    if ((*pp->pick->initial_metadata_flags & initial_metadata_flags_mask) ==
-        initial_metadata_flags_eq) {
-      // Note: pp is deleted in this callback.
-      GRPC_CLOSURE_SCHED(&pp->on_complete,
-                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Pick Cancelled", &error, 1));
-    } else {
-      pp->next = pending_picks_;
-      pending_picks_ = pp;
-    }
-    pp = next;
-  }
-  if (child_policy_ != nullptr) {
-    child_policy_->CancelMatchingPicksLocked(initial_metadata_flags_mask,
-                                             initial_metadata_flags_eq,
-                                             GRPC_ERROR_REF(error));
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-void XdsLb::ExitIdleLocked() {
-  if (!started_picking_) {
-    StartPickingLocked();
-  }
-}
-
 void XdsLb::ResetBackoffLocked() {
   if (lb_channel_ != nullptr) {
     grpc_channel_reset_connect_backoff(lb_channel_);
@@ -1103,36 +1035,6 @@ void XdsLb::ResetBackoffLocked() {
   }
 }
 
-bool XdsLb::PickLocked(PickState* pick, grpc_error** error) {
-  PendingPick* pp = PendingPickCreate(pick);
-  bool pick_done = false;
-  if (child_policy_ != nullptr) {
-    if (grpc_lb_xds_trace.enabled()) {
-      gpr_log(GPR_INFO, "[xdslb %p] about to PICK from policy %p", this,
-              child_policy_.get());
-    }
-    pick_done = PickFromChildPolicyLocked(false /* force_async */, pp, error);
-  } else {  // child_policy_ == NULL
-    if (pick->on_complete == nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "No pick result available but synchronous result required.");
-      pick_done = true;
-    } else {
-      if (grpc_lb_xds_trace.enabled()) {
-        gpr_log(GPR_INFO,
-                "[xdslb %p] No child policy. Adding to xds's pending picks",
-                this);
-      }
-      AddPendingPick(pp);
-      if (!started_picking_) {
-        StartPickingLocked();
-      }
-      pick_done = false;
-    }
-  }
-  return pick_done;
-}
-
 void XdsLb::FillChildRefsForChannelz(channelz::ChildRefsList* child_subchannels,
                                      channelz::ChildRefsList* child_channels) {
   // delegate to the child_policy_ to fill the children subchannels.
@@ -1147,17 +1049,6 @@ void XdsLb::FillChildRefsForChannelz(channelz::ChildRefsList* child_subchannels,
   }
 }
 
-grpc_connectivity_state XdsLb::CheckConnectivityLocked(
-    grpc_error** connectivity_error) {
-  return grpc_connectivity_state_get(&state_tracker_, connectivity_error);
-}
-
-void XdsLb::NotifyOnStateChangeLocked(grpc_connectivity_state* current,
-                                      grpc_closure* closure) {
-  grpc_connectivity_state_notify_on_state_change(&state_tracker_, current,
-                                                 closure);
-}
-
 void XdsLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
   const ServerAddressList* addresses = FindServerAddressListChannelArg(&args);
   if (addresses == nullptr) {
@@ -1185,9 +1076,8 @@ void XdsLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
     char* uri_str;
     gpr_asprintf(&uri_str, "fake:///%s", server_name_);
     gpr_mu_lock(&lb_channel_mu_);
-    lb_channel_ = grpc_client_channel_factory_create_channel(
-        client_channel_factory(), uri_str,
-        GRPC_CLIENT_CHANNEL_TYPE_LOAD_BALANCING, lb_channel_args);
+    lb_channel_ = channel_control_helper()->CreateChannel(
+        uri_str, GRPC_CLIENT_CHANNEL_TYPE_LOAD_BALANCING, *lb_channel_args);
     gpr_mu_unlock(&lb_channel_mu_);
     GPR_ASSERT(lb_channel_ != nullptr);
     gpr_free(uri_str);
@@ -1198,11 +1088,12 @@ void XdsLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
   grpc_channel_args_destroy(lb_channel_args);
 }
 
-void XdsLb::ParseLbConfig(grpc_json* xds_config_json) {
+void XdsLb::ParseLbConfig(Config* xds_config) {
+  const grpc_json* xds_config_json = xds_config->json();
   const char* balancer_name = nullptr;
   grpc_json* child_policy = nullptr;
   grpc_json* fallback_policy = nullptr;
-  for (grpc_json* field = xds_config_json; field != nullptr;
+  for (const grpc_json* field = xds_config_json; field != nullptr;
        field = field->next) {
     if (field->key == nullptr) return;
     if (strcmp(field->key, "balancerName") == 0) {
@@ -1219,18 +1110,22 @@ void XdsLb::ParseLbConfig(grpc_json* xds_config_json) {
   }
   if (balancer_name == nullptr) return;  // Required field.
   if (child_policy != nullptr) {
-    child_policy_json_string_ =
-        UniquePtr<char>(grpc_json_dump_to_string(child_policy, 0 /* indent */));
+    child_policy_name_ = UniquePtr<char>(gpr_strdup(child_policy->key));
+    child_policy_config_ = MakeRefCounted<Config>(child_policy->child,
+                                                  xds_config->service_config());
   }
   if (fallback_policy != nullptr) {
-    fallback_policy_json_string_ = UniquePtr<char>(
-        grpc_json_dump_to_string(fallback_policy, 0 /* indent */));
+    fallback_policy_name_ = UniquePtr<char>(gpr_strdup(fallback_policy->key));
+    fallback_policy_config_ = MakeRefCounted<Config>(
+        fallback_policy->child, xds_config->service_config());
   }
   balancer_name_ = UniquePtr<char>(gpr_strdup(balancer_name));
 }
 
-void XdsLb::UpdateLocked(const grpc_channel_args& args, grpc_json* lb_config) {
-  ParseLbConfig(lb_config);
+void XdsLb::UpdateLocked(const grpc_channel_args& args,
+                         RefCountedPtr<Config> lb_config) {
+  const bool is_initial_update = lb_channel_ == nullptr;
+  ParseLbConfig(lb_config.get());
   // TODO(juanlishen): Pass fallback policy config update after fallback policy
   // is added.
   if (balancer_name_ == nullptr) {
@@ -1243,20 +1138,30 @@ void XdsLb::UpdateLocked(const grpc_channel_args& args, grpc_json* lb_config) {
   // TODO(vpowar): Handle the fallback_address changes when we add support for
   // fallback in xDS.
   if (child_policy_ != nullptr) CreateOrUpdateChildPolicyLocked();
-  // Start watching the LB channel connectivity for connection, if not
-  // already doing so.
-  if (!watching_lb_channel_) {
+  // If this is the initial update, start the fallback timer.
+  if (is_initial_update) {
+    if (lb_fallback_timeout_ms_ > 0 && serverlist_ == nullptr &&
+        !fallback_timer_callback_pending_) {
+      grpc_millis deadline = ExecCtx::Get()->Now() + lb_fallback_timeout_ms_;
+      Ref(DEBUG_LOCATION, "on_fallback_timer").release();  // Held by closure
+      GRPC_CLOSURE_INIT(&lb_on_fallback_, &XdsLb::OnFallbackTimerLocked, this,
+                        grpc_combiner_scheduler(combiner()));
+      fallback_timer_callback_pending_ = true;
+      grpc_timer_init(&lb_fallback_timer_, deadline, &lb_on_fallback_);
+    }
+    StartBalancerCallLocked();
+  } else if (!watching_lb_channel_) {
+    // If this is not the initial update and we're not already watching
+    // the LB channel's connectivity state, start a watch now.  This
+    // ensures that we'll know when to switch to a new balancer call.
     lb_channel_connectivity_ = grpc_channel_check_connectivity_state(
         lb_channel_, true /* try to connect */);
     grpc_channel_element* client_channel_elem = grpc_channel_stack_last_element(
         grpc_channel_get_channel_stack(lb_channel_));
     GPR_ASSERT(client_channel_elem->filter == &grpc_client_channel_filter);
     watching_lb_channel_ = true;
-    // TODO(roth): We currently track this ref manually.  Once the
-    // ClosureRef API is ready, we should pass the RefCountedPtr<> along
-    // with the callback.
-    auto self = Ref(DEBUG_LOCATION, "watch_lb_channel_connectivity");
-    self.release();
+    // Ref held by closure.
+    Ref(DEBUG_LOCATION, "watch_lb_channel_connectivity").release();
     grpc_client_channel_watch_connectivity_state(
         client_channel_elem,
         grpc_polling_entity_create_from_pollset_set(interested_parties()),
@@ -1269,25 +1174,6 @@ void XdsLb::UpdateLocked(const grpc_channel_args& args, grpc_json* lb_config) {
 // code for balancer channel and call
 //
 
-void XdsLb::StartPickingLocked() {
-  // Start a timer to fall back.
-  if (lb_fallback_timeout_ms_ > 0 && serverlist_ == nullptr &&
-      !fallback_timer_callback_pending_) {
-    grpc_millis deadline = ExecCtx::Get()->Now() + lb_fallback_timeout_ms_;
-    // TODO(roth): We currently track this ref manually.  Once the
-    // ClosureRef API is ready, we should pass the RefCountedPtr<> along
-    // with the callback.
-    auto self = Ref(DEBUG_LOCATION, "on_fallback_timer");
-    self.release();
-    GRPC_CLOSURE_INIT(&lb_on_fallback_, &XdsLb::OnFallbackTimerLocked, this,
-                      grpc_combiner_scheduler(combiner()));
-    fallback_timer_callback_pending_ = true;
-    grpc_timer_init(&lb_fallback_timer_, deadline, &lb_on_fallback_);
-  }
-  started_picking_ = true;
-  StartBalancerCallLocked();
-}
-
 void XdsLb::StartBalancerCallLocked() {
   GPR_ASSERT(lb_channel_ != nullptr);
   if (shutting_down_) return;
@@ -1386,13 +1272,11 @@ void XdsLb::OnBalancerChannelConnectivityChangedLocked(void* arg,
     case GRPC_CHANNEL_IDLE:
     case GRPC_CHANNEL_READY:
       xdslb_policy->lb_calld_.reset();
-      if (xdslb_policy->started_picking_) {
-        if (xdslb_policy->retry_timer_callback_pending_) {
-          grpc_timer_cancel(&xdslb_policy->lb_call_retry_timer_);
-        }
-        xdslb_policy->lb_call_backoff_.Reset();
-        xdslb_policy->StartBalancerCallLocked();
+      if (xdslb_policy->retry_timer_callback_pending_) {
+        grpc_timer_cancel(&xdslb_policy->lb_call_retry_timer_);
       }
+      xdslb_policy->lb_call_backoff_.Reset();
+      xdslb_policy->StartBalancerCallLocked();
       // Fall through.
     case GRPC_CHANNEL_SHUTDOWN:
     done:
@@ -1402,145 +1286,17 @@ void XdsLb::OnBalancerChannelConnectivityChangedLocked(void* arg,
   }
 }
 
-//
-// PendingPick
-//
-
-// Destroy function used when embedding client stats in call context.
-void DestroyClientStats(void* arg) {
-  static_cast<XdsLbClientStats*>(arg)->Unref();
-}
-
-void XdsLb::PendingPickCleanup(PendingPick* pp) {
-  // If connected_subchannel is nullptr, no pick has been made by the
-  // child policy (e.g., all addresses failed to connect).
-  if (pp->pick->connected_subchannel != nullptr) {
-    // Pass on client stats via context. Passes ownership of the reference.
-    if (pp->client_stats != nullptr) {
-      pp->pick->subchannel_call_context[GRPC_GRPCLB_CLIENT_STATS].value =
-          pp->client_stats.release();
-      pp->pick->subchannel_call_context[GRPC_GRPCLB_CLIENT_STATS].destroy =
-          DestroyClientStats;
-    }
-  } else {
-    pp->client_stats.reset();
-  }
-}
-
-/* The \a on_complete closure passed as part of the pick requires keeping a
- * reference to its associated child policy instance. We wrap this closure in
- * order to unref the child policy instance upon its invocation */
-void XdsLb::OnPendingPickComplete(void* arg, grpc_error* error) {
-  PendingPick* pp = static_cast<PendingPick*>(arg);
-  PendingPickCleanup(pp);
-  GRPC_CLOSURE_SCHED(pp->original_on_complete, GRPC_ERROR_REF(error));
-  Delete(pp);
-}
-
-XdsLb::PendingPick* XdsLb::PendingPickCreate(PickState* pick) {
-  PendingPick* pp = New<PendingPick>();
-  pp->xdslb_policy = this;
-  pp->pick = pick;
-  GRPC_CLOSURE_INIT(&pp->on_complete, &XdsLb::OnPendingPickComplete, pp,
-                    grpc_schedule_on_exec_ctx);
-  pp->original_on_complete = pick->on_complete;
-  pick->on_complete = &pp->on_complete;
-  return pp;
-}
-
-void XdsLb::AddPendingPick(PendingPick* pp) {
-  pp->next = pending_picks_;
-  pending_picks_ = pp;
-}
-
 //
 // code for interacting with the child policy
 //
 
-// Performs a pick over \a child_policy_. Given that a pick can return
-// immediately (ignoring its completion callback), we need to perform the
-// cleanups this callback would otherwise be responsible for.
-// If \a force_async is true, then we will manually schedule the
-// completion callback even if the pick is available immediately.
-bool XdsLb::PickFromChildPolicyLocked(bool force_async, PendingPick* pp,
-                                      grpc_error** error) {
-  // Set client_stats.
-  if (lb_calld_ != nullptr && lb_calld_->client_stats() != nullptr) {
-    pp->client_stats = lb_calld_->client_stats()->Ref();
-  }
-  // Pick via the child policy.
-  bool pick_done = child_policy_->PickLocked(pp->pick, error);
-  if (pick_done) {
-    PendingPickCleanup(pp);
-    if (force_async) {
-      GRPC_CLOSURE_SCHED(pp->original_on_complete, *error);
-      *error = GRPC_ERROR_NONE;
-      pick_done = false;
-    }
-    Delete(pp);
-  }
-  // else, the pending pick will be registered and taken care of by the
-  // pending pick list inside the child policy.  Eventually,
-  // OnPendingPickComplete() will be called, which will (among other
-  // things) add the LB token to the call's initial metadata.
-  return pick_done;
-}
-
-void XdsLb::CreateChildPolicyLocked(const char* name, Args args) {
-  GPR_ASSERT(child_policy_ == nullptr);
-  child_policy_ = LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-      name, std::move(args));
-  if (GPR_UNLIKELY(child_policy_ == nullptr)) {
-    gpr_log(GPR_ERROR, "[xdslb %p] Failure creating a child policy", this);
-    return;
-  }
-  // TODO(roth): We currently track this ref manually.  Once the new
-  // ClosureRef API is done, pass the RefCountedPtr<> along with the closure.
-  auto self = Ref(DEBUG_LOCATION, "on_child_reresolution_requested");
-  self.release();
-  child_policy_->SetReresolutionClosureLocked(&on_child_request_reresolution_);
-  grpc_error* child_state_error = nullptr;
-  child_connectivity_state_ =
-      child_policy_->CheckConnectivityLocked(&child_state_error);
-  // Connectivity state is a function of the child policy updated/created.
-  UpdateConnectivityStateFromChildPolicyLocked(child_state_error);
-  // Add the xDS's interested_parties pollset_set to that of the newly created
-  // child policy. This will make the child policy progress upon activity on
-  // xDS LB, which in turn is tied to the application's call.
-  grpc_pollset_set_add_pollset_set(child_policy_->interested_parties(),
-                                   interested_parties());
-  // Subscribe to changes to the connectivity of the new child policy.
-  // TODO(roth): We currently track this ref manually.  Once the new
-  // ClosureRef API is done, pass the RefCountedPtr<> along with the closure.
-  self = Ref(DEBUG_LOCATION, "on_child_connectivity_changed");
-  self.release();
-  child_policy_->NotifyOnStateChangeLocked(&child_connectivity_state_,
-                                           &on_child_connectivity_changed_);
-  child_policy_->ExitIdleLocked();
-  // Send pending picks to child policy.
-  PendingPick* pp;
-  while ((pp = pending_picks_)) {
-    pending_picks_ = pp->next;
-    if (grpc_lb_xds_trace.enabled()) {
-      gpr_log(
-          GPR_INFO,
-          "[xdslb %p] Pending pick about to (async) PICK from child policy %p",
-          this, child_policy_.get());
-    }
-    grpc_error* error = GRPC_ERROR_NONE;
-    PickFromChildPolicyLocked(true /* force_async */, pp, &error);
-  }
-}
-
 grpc_channel_args* XdsLb::CreateChildPolicyArgsLocked() {
-  bool is_backend_from_grpclb_load_balancer = false;
   // This should never be invoked if we do not have serverlist_, as fallback
   // mode is disabled for xDS plugin.
   GPR_ASSERT(serverlist_ != nullptr);
   GPR_ASSERT(serverlist_->num_servers > 0);
   UniquePtr<ServerAddressList> addresses = ProcessServerlist(serverlist_);
   GPR_ASSERT(addresses != nullptr);
-  is_backend_from_grpclb_load_balancer = true;
   // Replace the server address list in the channel args that we pass down to
   // the subchannel.
   static const char* keys_to_remove[] = {GRPC_ARG_SERVER_ADDRESS_LIST};
@@ -1550,7 +1306,7 @@ grpc_channel_args* XdsLb::CreateChildPolicyArgsLocked() {
       // grpclb load balancer.
       grpc_channel_arg_integer_create(
           const_cast<char*>(GRPC_ARG_ADDRESS_IS_BACKEND_FROM_XDS_LOAD_BALANCER),
-          is_backend_from_grpclb_load_balancer),
+          1),
   };
   grpc_channel_args* args = grpc_channel_args_copy_and_add_and_remove(
       args_, keys_to_remove, GPR_ARRAY_SIZE(keys_to_remove), args_to_add,
@@ -1558,143 +1314,49 @@ grpc_channel_args* XdsLb::CreateChildPolicyArgsLocked() {
   return args;
 }
 
+void XdsLb::CreateChildPolicyLocked(const char* name, Args args) {
+  GPR_ASSERT(child_policy_ == nullptr);
+  child_policy_ = LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
+      name, std::move(args));
+  if (GPR_UNLIKELY(child_policy_ == nullptr)) {
+    gpr_log(GPR_ERROR, "[xdslb %p] Failure creating a child policy", this);
+    return;
+  }
+  // Add the xDS's interested_parties pollset_set to that of the newly created
+  // child policy. This will make the child policy progress upon activity on
+  // xDS LB, which in turn is tied to the application's call.
+  grpc_pollset_set_add_pollset_set(child_policy_->interested_parties(),
+                                   interested_parties());
+}
+
 void XdsLb::CreateOrUpdateChildPolicyLocked() {
   if (shutting_down_) return;
   grpc_channel_args* args = CreateChildPolicyArgsLocked();
   GPR_ASSERT(args != nullptr);
-  const char* child_policy_name = nullptr;
-  grpc_json* child_policy_config = nullptr;
-  grpc_json* child_policy_json =
-      grpc_json_parse_string(child_policy_json_string_.get());
   // TODO(juanlishen): If the child policy is not configured via service config,
   // use whatever algorithm is specified by the balancer.
-  if (child_policy_json != nullptr) {
-    child_policy_name = child_policy_json->key;
-    child_policy_config = child_policy_json->child;
-  } else {
-    if (grpc_lb_xds_trace.enabled()) {
-      gpr_log(GPR_INFO, "[xdslb %p] No valid child policy LB config", this);
-    }
-    child_policy_name = "round_robin";
-  }
   // TODO(juanlishen): Switch policy according to child_policy_config->key.
-  if (child_policy_ != nullptr) {
-    if (grpc_lb_xds_trace.enabled()) {
-      gpr_log(GPR_INFO, "[xdslb %p] Updating the child policy %p", this,
-              child_policy_.get());
-    }
-    child_policy_->UpdateLocked(*args, child_policy_config);
-  } else {
+  if (child_policy_ == nullptr) {
     LoadBalancingPolicy::Args lb_policy_args;
     lb_policy_args.combiner = combiner();
-    lb_policy_args.client_channel_factory = client_channel_factory();
-    lb_policy_args.subchannel_pool = subchannel_pool()->Ref();
     lb_policy_args.args = args;
-    lb_policy_args.lb_config = child_policy_config;
-    CreateChildPolicyLocked(child_policy_name, std::move(lb_policy_args));
+    lb_policy_args.channel_control_helper =
+        UniquePtr<ChannelControlHelper>(New<Helper>(Ref()));
+    CreateChildPolicyLocked(child_policy_name_ == nullptr
+                                ? "round_robin"
+                                : child_policy_name_.get(),
+                            std::move(lb_policy_args));
     if (grpc_lb_xds_trace.enabled()) {
       gpr_log(GPR_INFO, "[xdslb %p] Created a new child policy %p", this,
               child_policy_.get());
     }
   }
-  grpc_channel_args_destroy(args);
-  grpc_json_destroy(child_policy_json);
-}
-
-void XdsLb::OnChildPolicyRequestReresolutionLocked(void* arg,
-                                                   grpc_error* error) {
-  XdsLb* xdslb_policy = static_cast<XdsLb*>(arg);
-  if (xdslb_policy->shutting_down_ || error != GRPC_ERROR_NONE) {
-    xdslb_policy->Unref(DEBUG_LOCATION, "on_child_reresolution_requested");
-    return;
-  }
   if (grpc_lb_xds_trace.enabled()) {
-    gpr_log(GPR_INFO,
-            "[xdslb %p] Re-resolution requested from child policy "
-            "(%p).",
-            xdslb_policy, xdslb_policy->child_policy_.get());
-  }
-  // If we are talking to a balancer, we expect to get updated addresses form
-  // the balancer, so we can ignore the re-resolution request from the child
-  // policy.
-  // Otherwise, handle the re-resolution request using the xds policy's
-  // original re-resolution closure.
-  if (xdslb_policy->lb_calld_ == nullptr ||
-      !xdslb_policy->lb_calld_->seen_initial_response()) {
-    xdslb_policy->TryReresolutionLocked(&grpc_lb_xds_trace, GRPC_ERROR_NONE);
-  }
-  // Give back the wrapper closure to the child policy.
-  xdslb_policy->child_policy_->SetReresolutionClosureLocked(
-      &xdslb_policy->on_child_request_reresolution_);
-}
-
-void XdsLb::UpdateConnectivityStateFromChildPolicyLocked(
-    grpc_error* child_state_error) {
-  const grpc_connectivity_state curr_glb_state =
-      grpc_connectivity_state_check(&state_tracker_);
-  /* The new connectivity status is a function of the previous one and the new
-   * input coming from the status of the child policy.
-   *
-   *  current state (xds's)
-   *  |
-   *  v  || I  |  C  |  R  |  TF  |  SD  |  <- new state (child policy's)
-   *  ===++====+=====+=====+======+======+
-   *   I || I  |  C  |  R  | [I]  | [I]  |
-   *  ---++----+-----+-----+------+------+
-   *   C || I  |  C  |  R  | [C]  | [C]  |
-   *  ---++----+-----+-----+------+------+
-   *   R || I  |  C  |  R  | [R]  | [R]  |
-   *  ---++----+-----+-----+------+------+
-   *  TF || I  |  C  |  R  | [TF] | [TF] |
-   *  ---++----+-----+-----+------+------+
-   *  SD || NA |  NA |  NA |  NA  |  NA  | (*)
-   *  ---++----+-----+-----+------+------+
-   *
-   * A [STATE] indicates that the old child policy is kept. In those cases,
-   * STATE is the current state of xds, which is left untouched.
-   *
-   *  In summary, if the new state is TRANSIENT_FAILURE or SHUTDOWN, stick to
-   *  the previous child policy instance.
-   *
-   *  Note that the status is never updated to SHUTDOWN as a result of calling
-   *  this function. Only glb_shutdown() has the power to set that state.
-   *
-   *  (*) This function mustn't be called during shutting down. */
-  GPR_ASSERT(curr_glb_state != GRPC_CHANNEL_SHUTDOWN);
-  switch (child_connectivity_state_) {
-    case GRPC_CHANNEL_TRANSIENT_FAILURE:
-    case GRPC_CHANNEL_SHUTDOWN:
-      GPR_ASSERT(child_state_error != GRPC_ERROR_NONE);
-      break;
-    case GRPC_CHANNEL_IDLE:
-    case GRPC_CHANNEL_CONNECTING:
-    case GRPC_CHANNEL_READY:
-      GPR_ASSERT(child_state_error == GRPC_ERROR_NONE);
-  }
-  if (grpc_lb_xds_trace.enabled()) {
-    gpr_log(GPR_INFO,
-            "[xdslb %p] Setting xds's state to %s from child policy %p state.",
-            this, grpc_connectivity_state_name(child_connectivity_state_),
+    gpr_log(GPR_INFO, "[xdslb %p] Updating child policy %p", this,
             child_policy_.get());
   }
-  grpc_connectivity_state_set(&state_tracker_, child_connectivity_state_,
-                              child_state_error,
-                              "update_lb_connectivity_status_locked");
-}
-
-void XdsLb::OnChildPolicyConnectivityChangedLocked(void* arg,
-                                                   grpc_error* error) {
-  XdsLb* xdslb_policy = static_cast<XdsLb*>(arg);
-  if (xdslb_policy->shutting_down_) {
-    xdslb_policy->Unref(DEBUG_LOCATION, "on_child_connectivity_changed");
-    return;
-  }
-  xdslb_policy->UpdateConnectivityStateFromChildPolicyLocked(
-      GRPC_ERROR_REF(error));
-  // Resubscribe. Reuse the "on_child_connectivity_changed" ref.
-  xdslb_policy->child_policy_->NotifyOnStateChangeLocked(
-      &xdslb_policy->child_connectivity_state_,
-      &xdslb_policy->on_child_connectivity_changed_);
+  child_policy_->UpdateLocked(*args, child_policy_config_);
+  grpc_channel_args_destroy(args);
 }
 
 //

src/core/ext/filters/client_channel/lb_policy_factory.h

@@ -33,9 +33,7 @@ class LoadBalancingPolicyFactory {
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const {
     std::move(args);  // Suppress clang-tidy complaint.
-    // The rest of this is copied from the GRPC_ABSTRACT macro.
-    gpr_log(GPR_ERROR, "Function marked GRPC_ABSTRACT was not implemented");
-    GPR_ASSERT(false);
+    GRPC_ABSTRACT;
   }
 
   /// Returns the LB policy name that this factory provides.

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

@@ -1,946 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/request_routing.h"
-
-#include <inttypes.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/sync.h>
-
-#include "src/core/ext/filters/client_channel/backup_poller.h"
-#include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
-#include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/local_subchannel_pool.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-#include "src/core/ext/filters/client_channel/retry_throttle.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/ext/filters/deadline/deadline_filter.h"
-#include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/connected_channel.h"
-#include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/iomgr/combiner.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/service_config.h"
-#include "src/core/lib/transport/static_metadata.h"
-#include "src/core/lib/transport/status_metadata.h"
-
-namespace grpc_core {
-
-//
-// RequestRouter::Request::ResolverResultWaiter
-//
-
-// Handles waiting for a resolver result.
-// Used only for the first call on an idle channel.
-class RequestRouter::Request::ResolverResultWaiter {
- public:
-  explicit ResolverResultWaiter(Request* request)
-      : request_router_(request->request_router_),
-        request_(request),
-        tracer_enabled_(request_router_->tracer_->enabled()) {
-    if (tracer_enabled_) {
-      gpr_log(GPR_INFO,
-              "request_router=%p request=%p: deferring pick pending resolver "
-              "result",
-              request_router_, request);
-    }
-    // Add closure to be run when a resolver result is available.
-    GRPC_CLOSURE_INIT(&done_closure_, &DoneLocked, this,
-                      grpc_combiner_scheduler(request_router_->combiner_));
-    AddToWaitingList();
-    // Set cancellation closure, so that we abort if the call is cancelled.
-    GRPC_CLOSURE_INIT(&cancel_closure_, &CancelLocked, this,
-                      grpc_combiner_scheduler(request_router_->combiner_));
-    grpc_call_combiner_set_notify_on_cancel(request->call_combiner_,
-                                            &cancel_closure_);
-  }
-
- private:
-  // Adds done_closure_ to
-  // request_router_->waiting_for_resolver_result_closures_.
-  void AddToWaitingList() {
-    grpc_closure_list_append(
-        &request_router_->waiting_for_resolver_result_closures_, &done_closure_,
-        GRPC_ERROR_NONE);
-  }
-
-  // Invoked when a resolver result is available.
-  static void DoneLocked(void* arg, grpc_error* error) {
-    ResolverResultWaiter* self = static_cast<ResolverResultWaiter*>(arg);
-    RequestRouter* request_router = self->request_router_;
-    // If CancelLocked() has already run, delete ourselves without doing
-    // anything.  Note that the call stack may have already been destroyed,
-    // so it's not safe to access anything in state_.
-    if (GPR_UNLIKELY(self->finished_)) {
-      if (self->tracer_enabled_) {
-        gpr_log(GPR_INFO,
-                "request_router=%p: call cancelled before resolver result",
-                request_router);
-      }
-      Delete(self);
-      return;
-    }
-    // Otherwise, process the resolver result.
-    Request* request = self->request_;
-    if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
-      if (self->tracer_enabled_) {
-        gpr_log(GPR_INFO,
-                "request_router=%p request=%p: resolver failed to return data",
-                request_router, request);
-      }
-      GRPC_CLOSURE_RUN(request->on_route_done_, GRPC_ERROR_REF(error));
-    } else if (GPR_UNLIKELY(request_router->resolver_ == nullptr)) {
-      // Shutting down.
-      if (self->tracer_enabled_) {
-        gpr_log(GPR_INFO, "request_router=%p request=%p: resolver disconnected",
-                request_router, request);
-      }
-      GRPC_CLOSURE_RUN(request->on_route_done_,
-                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
-    } else if (GPR_UNLIKELY(request_router->lb_policy_ == nullptr)) {
-      // Transient resolver failure.
-      // If call has wait_for_ready=true, try again; otherwise, fail.
-      if (*request->pick_.initial_metadata_flags &
-          GRPC_INITIAL_METADATA_WAIT_FOR_READY) {
-        if (self->tracer_enabled_) {
-          gpr_log(GPR_INFO,
-                  "request_router=%p request=%p: resolver returned but no LB "
-                  "policy; wait_for_ready=true; trying again",
-                  request_router, request);
-        }
-        // Re-add ourselves to the waiting list.
-        self->AddToWaitingList();
-        // Return early so that we don't set finished_ to true below.
-        return;
-      } else {
-        if (self->tracer_enabled_) {
-          gpr_log(GPR_INFO,
-                  "request_router=%p request=%p: resolver returned but no LB "
-                  "policy; wait_for_ready=false; failing",
-                  request_router, request);
-        }
-        GRPC_CLOSURE_RUN(
-            request->on_route_done_,
-            grpc_error_set_int(
-                GRPC_ERROR_CREATE_FROM_STATIC_STRING("Name resolution failure"),
-                GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
-      }
-    } else {
-      if (self->tracer_enabled_) {
-        gpr_log(GPR_INFO,
-                "request_router=%p request=%p: resolver returned, doing LB "
-                "pick",
-                request_router, request);
-      }
-      request->ProcessServiceConfigAndStartLbPickLocked();
-    }
-    self->finished_ = true;
-  }
-
-  // Invoked when the call is cancelled.
-  // Note: This runs under the client_channel combiner, but will NOT be
-  // holding the call combiner.
-  static void CancelLocked(void* arg, grpc_error* error) {
-    ResolverResultWaiter* self = static_cast<ResolverResultWaiter*>(arg);
-    RequestRouter* request_router = self->request_router_;
-    // If DoneLocked() has already run, delete ourselves without doing anything.
-    if (self->finished_) {
-      Delete(self);
-      return;
-    }
-    Request* request = self->request_;
-    // If we are being cancelled, immediately invoke on_route_done_
-    // to propagate the error back to the caller.
-    if (error != GRPC_ERROR_NONE) {
-      if (self->tracer_enabled_) {
-        gpr_log(GPR_INFO,
-                "request_router=%p request=%p: cancelling call waiting for "
-                "name resolution",
-                request_router, request);
-      }
-      // Note: Although we are not in the call combiner here, we are
-      // basically stealing the call combiner from the pending pick, so
-      // it's safe to run on_route_done_ here -- we are essentially
-      // calling it here instead of calling it in DoneLocked().
-      GRPC_CLOSURE_RUN(request->on_route_done_,
-                       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                           "Pick cancelled", &error, 1));
-    }
-    self->finished_ = true;
-  }
-
-  RequestRouter* request_router_;
-  Request* request_;
-  const bool tracer_enabled_;
-  grpc_closure done_closure_;
-  grpc_closure cancel_closure_;
-  bool finished_ = false;
-};
-
-//
-// RequestRouter::Request::AsyncPickCanceller
-//
-
-// Handles the call combiner cancellation callback for an async LB pick.
-class RequestRouter::Request::AsyncPickCanceller {
- public:
-  explicit AsyncPickCanceller(Request* request)
-      : request_router_(request->request_router_),
-        request_(request),
-        tracer_enabled_(request_router_->tracer_->enabled()) {
-    GRPC_CALL_STACK_REF(request->owning_call_, "pick_callback_cancel");
-    // Set cancellation closure, so that we abort if the call is cancelled.
-    GRPC_CLOSURE_INIT(&cancel_closure_, &CancelLocked, this,
-                      grpc_combiner_scheduler(request_router_->combiner_));
-    grpc_call_combiner_set_notify_on_cancel(request->call_combiner_,
-                                            &cancel_closure_);
-  }
-
-  void MarkFinishedLocked() {
-    finished_ = true;
-    GRPC_CALL_STACK_UNREF(request_->owning_call_, "pick_callback_cancel");
-  }
-
- private:
-  // Invoked when the call is cancelled.
-  // Note: This runs under the client_channel combiner, but will NOT be
-  // holding the call combiner.
-  static void CancelLocked(void* arg, grpc_error* error) {
-    AsyncPickCanceller* self = static_cast<AsyncPickCanceller*>(arg);
-    Request* request = self->request_;
-    RequestRouter* request_router = self->request_router_;
-    if (!self->finished_) {
-      // Note: request_router->lb_policy_ may have changed since we started our
-      // pick, in which case we will be cancelling the pick on a policy other
-      // than the one we started it on.  However, this will just be a no-op.
-      if (error != GRPC_ERROR_NONE && request_router->lb_policy_ != nullptr) {
-        if (self->tracer_enabled_) {
-          gpr_log(GPR_INFO,
-                  "request_router=%p request=%p: cancelling pick from LB "
-                  "policy %p",
-                  request_router, request, request_router->lb_policy_.get());
-        }
-        request_router->lb_policy_->CancelPickLocked(&request->pick_,
-                                                     GRPC_ERROR_REF(error));
-      }
-      request->pick_canceller_ = nullptr;
-      GRPC_CALL_STACK_UNREF(request->owning_call_, "pick_callback_cancel");
-    }
-    Delete(self);
-  }
-
-  RequestRouter* request_router_;
-  Request* request_;
-  const bool tracer_enabled_;
-  grpc_closure cancel_closure_;
-  bool finished_ = false;
-};
-
-//
-// RequestRouter::Request
-//
-
-RequestRouter::Request::Request(grpc_call_stack* owning_call,
-                                grpc_call_combiner* call_combiner,
-                                grpc_polling_entity* pollent,
-                                grpc_metadata_batch* send_initial_metadata,
-                                uint32_t* send_initial_metadata_flags,
-                                ApplyServiceConfigCallback apply_service_config,
-                                void* apply_service_config_user_data,
-                                grpc_closure* on_route_done)
-    : owning_call_(owning_call),
-      call_combiner_(call_combiner),
-      pollent_(pollent),
-      apply_service_config_(apply_service_config),
-      apply_service_config_user_data_(apply_service_config_user_data),
-      on_route_done_(on_route_done) {
-  pick_.initial_metadata = send_initial_metadata;
-  pick_.initial_metadata_flags = send_initial_metadata_flags;
-}
-
-RequestRouter::Request::~Request() {
-  if (pick_.connected_subchannel != nullptr) {
-    pick_.connected_subchannel.reset();
-  }
-  for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
-    if (pick_.subchannel_call_context[i].destroy != nullptr) {
-      pick_.subchannel_call_context[i].destroy(
-          pick_.subchannel_call_context[i].value);
-    }
-  }
-}
-
-// Invoked once resolver results are available.
-void RequestRouter::Request::ProcessServiceConfigAndStartLbPickLocked() {
-  // Get service config data if needed.
-  if (!apply_service_config_(apply_service_config_user_data_)) return;
-  // Start LB pick.
-  StartLbPickLocked();
-}
-
-void RequestRouter::Request::MaybeAddCallToInterestedPartiesLocked() {
-  if (!pollent_added_to_interested_parties_) {
-    pollent_added_to_interested_parties_ = true;
-    grpc_polling_entity_add_to_pollset_set(
-        pollent_, request_router_->interested_parties_);
-  }
-}
-
-void RequestRouter::Request::MaybeRemoveCallFromInterestedPartiesLocked() {
-  if (pollent_added_to_interested_parties_) {
-    pollent_added_to_interested_parties_ = false;
-    grpc_polling_entity_del_from_pollset_set(
-        pollent_, request_router_->interested_parties_);
-  }
-}
-
-// Starts a pick on the LB policy.
-void RequestRouter::Request::StartLbPickLocked() {
-  if (request_router_->tracer_->enabled()) {
-    gpr_log(GPR_INFO,
-            "request_router=%p request=%p: starting pick on lb_policy=%p",
-            request_router_, this, request_router_->lb_policy_.get());
-  }
-  GRPC_CLOSURE_INIT(&on_pick_done_, &LbPickDoneLocked, this,
-                    grpc_combiner_scheduler(request_router_->combiner_));
-  pick_.on_complete = &on_pick_done_;
-  GRPC_CALL_STACK_REF(owning_call_, "pick_callback");
-  grpc_error* error = GRPC_ERROR_NONE;
-  const bool pick_done =
-      request_router_->lb_policy_->PickLocked(&pick_, &error);
-  if (pick_done) {
-    // Pick completed synchronously.
-    if (request_router_->tracer_->enabled()) {
-      gpr_log(GPR_INFO,
-              "request_router=%p request=%p: pick completed synchronously",
-              request_router_, this);
-    }
-    GRPC_CLOSURE_RUN(on_route_done_, error);
-    GRPC_CALL_STACK_UNREF(owning_call_, "pick_callback");
-  } else {
-    // Pick will be returned asynchronously.
-    // Add the request's polling entity to the request_router's
-    // interested_parties, so that the I/O of the LB policy can be done
-    // under it.  It will be removed in LbPickDoneLocked().
-    MaybeAddCallToInterestedPartiesLocked();
-    // Request notification on call cancellation.
-    // We allocate a separate object to track cancellation, since the
-    // cancellation closure might still be pending when we need to reuse
-    // the memory in which this Request object is stored for a subsequent
-    // retry attempt.
-    pick_canceller_ = New<AsyncPickCanceller>(this);
-  }
-}
-
-// Callback invoked by LoadBalancingPolicy::PickLocked() for async picks.
-// Unrefs the LB policy and invokes on_route_done_.
-void RequestRouter::Request::LbPickDoneLocked(void* arg, grpc_error* error) {
-  Request* self = static_cast<Request*>(arg);
-  RequestRouter* request_router = self->request_router_;
-  if (request_router->tracer_->enabled()) {
-    gpr_log(GPR_INFO,
-            "request_router=%p request=%p: pick completed asynchronously",
-            request_router, self);
-  }
-  self->MaybeRemoveCallFromInterestedPartiesLocked();
-  if (self->pick_canceller_ != nullptr) {
-    self->pick_canceller_->MarkFinishedLocked();
-  }
-  GRPC_CLOSURE_RUN(self->on_route_done_, GRPC_ERROR_REF(error));
-  GRPC_CALL_STACK_UNREF(self->owning_call_, "pick_callback");
-}
-
-//
-// RequestRouter::LbConnectivityWatcher
-//
-
-class RequestRouter::LbConnectivityWatcher {
- public:
-  LbConnectivityWatcher(RequestRouter* request_router,
-                        grpc_connectivity_state state,
-                        LoadBalancingPolicy* lb_policy,
-                        grpc_channel_stack* owning_stack,
-                        grpc_combiner* combiner)
-      : request_router_(request_router),
-        state_(state),
-        lb_policy_(lb_policy),
-        owning_stack_(owning_stack) {
-    GRPC_CHANNEL_STACK_REF(owning_stack_, "LbConnectivityWatcher");
-    GRPC_CLOSURE_INIT(&on_changed_, &OnLbPolicyStateChangedLocked, this,
-                      grpc_combiner_scheduler(combiner));
-    lb_policy_->NotifyOnStateChangeLocked(&state_, &on_changed_);
-  }
-
-  ~LbConnectivityWatcher() {
-    GRPC_CHANNEL_STACK_UNREF(owning_stack_, "LbConnectivityWatcher");
-  }
-
- private:
-  static void OnLbPolicyStateChangedLocked(void* arg, grpc_error* error) {
-    LbConnectivityWatcher* self = static_cast<LbConnectivityWatcher*>(arg);
-    // If the notification is not for the current policy, we're stale,
-    // so delete ourselves.
-    if (self->lb_policy_ != self->request_router_->lb_policy_.get()) {
-      Delete(self);
-      return;
-    }
-    // Otherwise, process notification.
-    if (self->request_router_->tracer_->enabled()) {
-      gpr_log(GPR_INFO, "request_router=%p: lb_policy=%p state changed to %s",
-              self->request_router_, self->lb_policy_,
-              grpc_connectivity_state_name(self->state_));
-    }
-    self->request_router_->SetConnectivityStateLocked(
-        self->state_, GRPC_ERROR_REF(error), "lb_changed");
-    // If shutting down, terminate watch.
-    if (self->state_ == GRPC_CHANNEL_SHUTDOWN) {
-      Delete(self);
-      return;
-    }
-    // Renew watch.
-    self->lb_policy_->NotifyOnStateChangeLocked(&self->state_,
-                                                &self->on_changed_);
-  }
-
-  RequestRouter* request_router_;
-  grpc_connectivity_state state_;
-  // LB policy address. No ref held, so not safe to dereference unless
-  // it happens to match request_router->lb_policy_.
-  LoadBalancingPolicy* lb_policy_;
-  grpc_channel_stack* owning_stack_;
-  grpc_closure on_changed_;
-};
-
-//
-// RequestRounter::ReresolutionRequestHandler
-//
-
-class RequestRouter::ReresolutionRequestHandler {
- public:
-  ReresolutionRequestHandler(RequestRouter* request_router,
-                             LoadBalancingPolicy* lb_policy,
-                             grpc_channel_stack* owning_stack,
-                             grpc_combiner* combiner)
-      : request_router_(request_router),
-        lb_policy_(lb_policy),
-        owning_stack_(owning_stack) {
-    GRPC_CHANNEL_STACK_REF(owning_stack_, "ReresolutionRequestHandler");
-    GRPC_CLOSURE_INIT(&closure_, &OnRequestReresolutionLocked, this,
-                      grpc_combiner_scheduler(combiner));
-    lb_policy_->SetReresolutionClosureLocked(&closure_);
-  }
-
- private:
-  static void OnRequestReresolutionLocked(void* arg, grpc_error* error) {
-    ReresolutionRequestHandler* self =
-        static_cast<ReresolutionRequestHandler*>(arg);
-    RequestRouter* request_router = self->request_router_;
-    // If this invocation is for a stale LB policy, treat it as an LB shutdown
-    // signal.
-    if (self->lb_policy_ != request_router->lb_policy_.get() ||
-        error != GRPC_ERROR_NONE || request_router->resolver_ == nullptr) {
-      GRPC_CHANNEL_STACK_UNREF(request_router->owning_stack_,
-                               "ReresolutionRequestHandler");
-      Delete(self);
-      return;
-    }
-    if (request_router->tracer_->enabled()) {
-      gpr_log(GPR_INFO, "request_router=%p: started name re-resolving",
-              request_router);
-    }
-    request_router->resolver_->RequestReresolutionLocked();
-    // Give back the closure to the LB policy.
-    self->lb_policy_->SetReresolutionClosureLocked(&self->closure_);
-  }
-
-  RequestRouter* request_router_;
-  // LB policy address. No ref held, so not safe to dereference unless
-  // it happens to match request_router->lb_policy_.
-  LoadBalancingPolicy* lb_policy_;
-  grpc_channel_stack* owning_stack_;
-  grpc_closure closure_;
-};
-
-//
-// RequestRouter
-//
-
-RequestRouter::RequestRouter(
-    grpc_channel_stack* owning_stack, grpc_combiner* combiner,
-    grpc_client_channel_factory* client_channel_factory,
-    grpc_pollset_set* interested_parties, TraceFlag* tracer,
-    ProcessResolverResultCallback process_resolver_result,
-    void* process_resolver_result_user_data, const char* target_uri,
-    const grpc_channel_args* args, grpc_error** error)
-    : owning_stack_(owning_stack),
-      combiner_(combiner),
-      client_channel_factory_(client_channel_factory),
-      interested_parties_(interested_parties),
-      tracer_(tracer),
-      process_resolver_result_(process_resolver_result),
-      process_resolver_result_user_data_(process_resolver_result_user_data) {
-  // Get subchannel pool.
-  const grpc_arg* arg =
-      grpc_channel_args_find(args, GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL);
-  if (grpc_channel_arg_get_bool(arg, false)) {
-    subchannel_pool_ = MakeRefCounted<LocalSubchannelPool>();
-  } else {
-    subchannel_pool_ = GlobalSubchannelPool::instance();
-  }
-  GRPC_CLOSURE_INIT(&on_resolver_result_changed_,
-                    &RequestRouter::OnResolverResultChangedLocked, this,
-                    grpc_combiner_scheduler(combiner));
-  grpc_connectivity_state_init(&state_tracker_, GRPC_CHANNEL_IDLE,
-                               "request_router");
-  grpc_channel_args* new_args = nullptr;
-  if (process_resolver_result == nullptr) {
-    grpc_arg arg = grpc_channel_arg_integer_create(
-        const_cast<char*>(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION), 0);
-    new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
-  }
-  resolver_ = ResolverRegistry::CreateResolver(
-      target_uri, (new_args == nullptr ? args : new_args), interested_parties_,
-      combiner_);
-  grpc_channel_args_destroy(new_args);
-  if (resolver_ == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("resolver creation failed");
-  }
-}
-
-RequestRouter::~RequestRouter() {
-  if (resolver_ != nullptr) {
-    // The only way we can get here is if we never started resolving,
-    // because we take a ref to the channel stack when we start
-    // resolving and do not release it until the resolver callback is
-    // invoked after the resolver shuts down.
-    resolver_.reset();
-  }
-  if (lb_policy_ != nullptr) {
-    grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
-                                     interested_parties_);
-    lb_policy_.reset();
-  }
-  if (client_channel_factory_ != nullptr) {
-    grpc_client_channel_factory_unref(client_channel_factory_);
-  }
-  grpc_connectivity_state_destroy(&state_tracker_);
-}
-
-namespace {
-
-const char* GetChannelConnectivityStateChangeString(
-    grpc_connectivity_state state) {
-  switch (state) {
-    case GRPC_CHANNEL_IDLE:
-      return "Channel state change to IDLE";
-    case GRPC_CHANNEL_CONNECTING:
-      return "Channel state change to CONNECTING";
-    case GRPC_CHANNEL_READY:
-      return "Channel state change to READY";
-    case GRPC_CHANNEL_TRANSIENT_FAILURE:
-      return "Channel state change to TRANSIENT_FAILURE";
-    case GRPC_CHANNEL_SHUTDOWN:
-      return "Channel state change to SHUTDOWN";
-  }
-  GPR_UNREACHABLE_CODE(return "UNKNOWN");
-}
-
-}  // namespace
-
-void RequestRouter::SetConnectivityStateLocked(grpc_connectivity_state state,
-                                               grpc_error* error,
-                                               const char* reason) {
-  if (lb_policy_ != nullptr) {
-    if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-      // Cancel picks with wait_for_ready=false.
-      lb_policy_->CancelMatchingPicksLocked(
-          /* mask= */ GRPC_INITIAL_METADATA_WAIT_FOR_READY,
-          /* check= */ 0, GRPC_ERROR_REF(error));
-    } else if (state == GRPC_CHANNEL_SHUTDOWN) {
-      // Cancel all picks.
-      lb_policy_->CancelMatchingPicksLocked(/* mask= */ 0, /* check= */ 0,
-                                            GRPC_ERROR_REF(error));
-    }
-  }
-  if (tracer_->enabled()) {
-    gpr_log(GPR_INFO, "request_router=%p: setting connectivity state to %s",
-            this, grpc_connectivity_state_name(state));
-  }
-  if (channelz_node_ != nullptr) {
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string(
-            GetChannelConnectivityStateChangeString(state)));
-  }
-  grpc_connectivity_state_set(&state_tracker_, state, error, reason);
-}
-
-void RequestRouter::StartResolvingLocked() {
-  if (tracer_->enabled()) {
-    gpr_log(GPR_INFO, "request_router=%p: starting name resolution", this);
-  }
-  GPR_ASSERT(!started_resolving_);
-  started_resolving_ = true;
-  GRPC_CHANNEL_STACK_REF(owning_stack_, "resolver");
-  resolver_->NextLocked(&resolver_result_, &on_resolver_result_changed_);
-}
-
-// Invoked from the resolver NextLocked() callback when the resolver
-// is shutting down.
-void RequestRouter::OnResolverShutdownLocked(grpc_error* error) {
-  if (tracer_->enabled()) {
-    gpr_log(GPR_INFO, "request_router=%p: shutting down", this);
-  }
-  if (lb_policy_ != nullptr) {
-    if (tracer_->enabled()) {
-      gpr_log(GPR_INFO, "request_router=%p: shutting down lb_policy=%p", this,
-              lb_policy_.get());
-    }
-    grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
-                                     interested_parties_);
-    lb_policy_.reset();
-  }
-  if (resolver_ != nullptr) {
-    // This should never happen; it can only be triggered by a resolver
-    // implementation spotaneously deciding to report shutdown without
-    // being orphaned.  This code is included just to be defensive.
-    if (tracer_->enabled()) {
-      gpr_log(GPR_INFO,
-              "request_router=%p: spontaneous shutdown from resolver %p", this,
-              resolver_.get());
-    }
-    resolver_.reset();
-    SetConnectivityStateLocked(GRPC_CHANNEL_SHUTDOWN,
-                               GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                                   "Resolver spontaneous shutdown", &error, 1),
-                               "resolver_spontaneous_shutdown");
-  }
-  grpc_closure_list_fail_all(&waiting_for_resolver_result_closures_,
-                             GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                                 "Channel disconnected", &error, 1));
-  GRPC_CLOSURE_LIST_SCHED(&waiting_for_resolver_result_closures_);
-  GRPC_CHANNEL_STACK_UNREF(owning_stack_, "resolver");
-  grpc_channel_args_destroy(resolver_result_);
-  resolver_result_ = nullptr;
-  GRPC_ERROR_UNREF(error);
-}
-
-// Creates a new LB policy, replacing any previous one.
-// If the new policy is created successfully, sets *connectivity_state and
-// *connectivity_error to its initial connectivity state; otherwise,
-// leaves them unchanged.
-void RequestRouter::CreateNewLbPolicyLocked(
-    const char* lb_policy_name, grpc_json* lb_config,
-    grpc_connectivity_state* connectivity_state,
-    grpc_error** connectivity_error, TraceStringVector* trace_strings) {
-  LoadBalancingPolicy::Args lb_policy_args;
-  lb_policy_args.combiner = combiner_;
-  lb_policy_args.client_channel_factory = client_channel_factory_;
-  lb_policy_args.subchannel_pool = subchannel_pool_;
-  lb_policy_args.args = resolver_result_;
-  lb_policy_args.lb_config = lb_config;
-  OrphanablePtr<LoadBalancingPolicy> new_lb_policy =
-      LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(lb_policy_name,
-                                                             lb_policy_args);
-  if (GPR_UNLIKELY(new_lb_policy == nullptr)) {
-    gpr_log(GPR_ERROR, "could not create LB policy \"%s\"", lb_policy_name);
-    if (channelz_node_ != nullptr) {
-      char* str;
-      gpr_asprintf(&str, "Could not create LB policy \'%s\'", lb_policy_name);
-      trace_strings->push_back(str);
-    }
-  } else {
-    if (tracer_->enabled()) {
-      gpr_log(GPR_INFO, "request_router=%p: created new LB policy \"%s\" (%p)",
-              this, lb_policy_name, new_lb_policy.get());
-    }
-    if (channelz_node_ != nullptr) {
-      char* str;
-      gpr_asprintf(&str, "Created new LB policy \'%s\'", lb_policy_name);
-      trace_strings->push_back(str);
-    }
-    // Swap out the LB policy and update the fds in interested_parties_.
-    if (lb_policy_ != nullptr) {
-      if (tracer_->enabled()) {
-        gpr_log(GPR_INFO, "request_router=%p: shutting down lb_policy=%p", this,
-                lb_policy_.get());
-      }
-      grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
-                                       interested_parties_);
-      lb_policy_->HandOffPendingPicksLocked(new_lb_policy.get());
-    }
-    lb_policy_ = std::move(new_lb_policy);
-    grpc_pollset_set_add_pollset_set(lb_policy_->interested_parties(),
-                                     interested_parties_);
-    // Create re-resolution request handler for the new LB policy.  It
-    // will delete itself when no longer needed.
-    New<ReresolutionRequestHandler>(this, lb_policy_.get(), owning_stack_,
-                                    combiner_);
-    // Get the new LB policy's initial connectivity state and start a
-    // connectivity watch.
-    GRPC_ERROR_UNREF(*connectivity_error);
-    *connectivity_state =
-        lb_policy_->CheckConnectivityLocked(connectivity_error);
-    if (exit_idle_when_lb_policy_arrives_) {
-      lb_policy_->ExitIdleLocked();
-      exit_idle_when_lb_policy_arrives_ = false;
-    }
-    // Create new watcher.  It will delete itself when done.
-    New<LbConnectivityWatcher>(this, *connectivity_state, lb_policy_.get(),
-                               owning_stack_, combiner_);
-  }
-}
-
-void RequestRouter::MaybeAddTraceMessagesForAddressChangesLocked(
-    TraceStringVector* trace_strings) {
-  const ServerAddressList* addresses =
-      FindServerAddressListChannelArg(resolver_result_);
-  const bool resolution_contains_addresses =
-      addresses != nullptr && addresses->size() > 0;
-  if (!resolution_contains_addresses &&
-      previous_resolution_contained_addresses_) {
-    trace_strings->push_back(gpr_strdup("Address list became empty"));
-  } else if (resolution_contains_addresses &&
-             !previous_resolution_contained_addresses_) {
-    trace_strings->push_back(gpr_strdup("Address list became non-empty"));
-  }
-  previous_resolution_contained_addresses_ = resolution_contains_addresses;
-}
-
-void RequestRouter::ConcatenateAndAddChannelTraceLocked(
-    TraceStringVector* trace_strings) const {
-  if (!trace_strings->empty()) {
-    gpr_strvec v;
-    gpr_strvec_init(&v);
-    gpr_strvec_add(&v, gpr_strdup("Resolution event: "));
-    bool is_first = 1;
-    for (size_t i = 0; i < trace_strings->size(); ++i) {
-      if (!is_first) gpr_strvec_add(&v, gpr_strdup(", "));
-      is_first = false;
-      gpr_strvec_add(&v, (*trace_strings)[i]);
-    }
-    char* flat;
-    size_t flat_len = 0;
-    flat = gpr_strvec_flatten(&v, &flat_len);
-    channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                  grpc_slice_new(flat, flat_len, gpr_free));
-    gpr_strvec_destroy(&v);
-  }
-}
-
-// Callback invoked when a resolver result is available.
-void RequestRouter::OnResolverResultChangedLocked(void* arg,
-                                                  grpc_error* error) {
-  RequestRouter* self = static_cast<RequestRouter*>(arg);
-  if (self->tracer_->enabled()) {
-    const char* disposition =
-        self->resolver_result_ != nullptr
-            ? ""
-            : (error == GRPC_ERROR_NONE ? " (transient error)"
-                                        : " (resolver shutdown)");
-    gpr_log(GPR_INFO,
-            "request_router=%p: got resolver result: resolver_result=%p "
-            "error=%s%s",
-            self, self->resolver_result_, grpc_error_string(error),
-            disposition);
-  }
-  // Handle shutdown.
-  if (error != GRPC_ERROR_NONE || self->resolver_ == nullptr) {
-    self->OnResolverShutdownLocked(GRPC_ERROR_REF(error));
-    return;
-  }
-  // Data used to set the channel's connectivity state.
-  bool set_connectivity_state = true;
-  // We only want to trace the address resolution in the follow cases:
-  // (a) Address resolution resulted in service config change.
-  // (b) Address resolution that causes number of backends to go from
-  //     zero to non-zero.
-  // (c) Address resolution that causes number of backends to go from
-  //     non-zero to zero.
-  // (d) Address resolution that causes a new LB policy to be created.
-  //
-  // we track a list of strings to eventually be concatenated and traced.
-  TraceStringVector trace_strings;
-  grpc_connectivity_state connectivity_state = GRPC_CHANNEL_TRANSIENT_FAILURE;
-  grpc_error* connectivity_error =
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("No load balancing policy");
-  // resolver_result_ will be null in the case of a transient
-  // resolution error.  In that case, we don't have any new result to
-  // process, which means that we keep using the previous result (if any).
-  if (self->resolver_result_ == nullptr) {
-    if (self->tracer_->enabled()) {
-      gpr_log(GPR_INFO, "request_router=%p: resolver transient failure", self);
-    }
-    // Don't override connectivity state if we already have an LB policy.
-    if (self->lb_policy_ != nullptr) set_connectivity_state = false;
-  } else {
-    // Parse the resolver result.
-    const char* lb_policy_name = nullptr;
-    grpc_json* lb_policy_config = nullptr;
-    const bool service_config_changed = self->process_resolver_result_(
-        self->process_resolver_result_user_data_, *self->resolver_result_,
-        &lb_policy_name, &lb_policy_config);
-    GPR_ASSERT(lb_policy_name != nullptr);
-    // Check to see if we're already using the right LB policy.
-    const bool lb_policy_name_changed =
-        self->lb_policy_ == nullptr ||
-        strcmp(self->lb_policy_->name(), lb_policy_name) != 0;
-    if (self->lb_policy_ != nullptr && !lb_policy_name_changed) {
-      // Continue using the same LB policy.  Update with new addresses.
-      if (self->tracer_->enabled()) {
-        gpr_log(GPR_INFO,
-                "request_router=%p: updating existing LB policy \"%s\" (%p)",
-                self, lb_policy_name, self->lb_policy_.get());
-      }
-      self->lb_policy_->UpdateLocked(*self->resolver_result_, lb_policy_config);
-      // No need to set the channel's connectivity state; the existing
-      // watch on the LB policy will take care of that.
-      set_connectivity_state = false;
-    } else {
-      // Instantiate new LB policy.
-      self->CreateNewLbPolicyLocked(lb_policy_name, lb_policy_config,
-                                    &connectivity_state, &connectivity_error,
-                                    &trace_strings);
-    }
-    // Add channel trace event.
-    if (self->channelz_node_ != nullptr) {
-      if (service_config_changed) {
-        // TODO(ncteisen): might be worth somehow including a snippet of the
-        // config in the trace, at the risk of bloating the trace logs.
-        trace_strings.push_back(gpr_strdup("Service config changed"));
-      }
-      self->MaybeAddTraceMessagesForAddressChangesLocked(&trace_strings);
-      self->ConcatenateAndAddChannelTraceLocked(&trace_strings);
-    }
-    // Clean up.
-    grpc_channel_args_destroy(self->resolver_result_);
-    self->resolver_result_ = nullptr;
-  }
-  // Set the channel's connectivity state if needed.
-  if (set_connectivity_state) {
-    self->SetConnectivityStateLocked(connectivity_state, connectivity_error,
-                                     "resolver_result");
-  } else {
-    GRPC_ERROR_UNREF(connectivity_error);
-  }
-  // Invoke closures that were waiting for results and renew the watch.
-  GRPC_CLOSURE_LIST_SCHED(&self->waiting_for_resolver_result_closures_);
-  self->resolver_->NextLocked(&self->resolver_result_,
-                              &self->on_resolver_result_changed_);
-}
-
-void RequestRouter::RouteCallLocked(Request* request) {
-  GPR_ASSERT(request->pick_.connected_subchannel == nullptr);
-  request->request_router_ = this;
-  if (lb_policy_ != nullptr) {
-    // We already have resolver results, so process the service config
-    // and start an LB pick.
-    request->ProcessServiceConfigAndStartLbPickLocked();
-  } else if (resolver_ == nullptr) {
-    GRPC_CLOSURE_RUN(request->on_route_done_,
-                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
-  } else {
-    // We do not yet have an LB policy, so wait for a resolver result.
-    if (!started_resolving_) {
-      StartResolvingLocked();
-    }
-    // Create a new waiter, which will delete itself when done.
-    New<Request::ResolverResultWaiter>(request);
-    // Add the request's polling entity to the request_router's
-    // interested_parties, so that the I/O of the resolver can be done
-    // under it.  It will be removed in LbPickDoneLocked().
-    request->MaybeAddCallToInterestedPartiesLocked();
-  }
-}
-
-void RequestRouter::ShutdownLocked(grpc_error* error) {
-  if (resolver_ != nullptr) {
-    SetConnectivityStateLocked(GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(error),
-                               "disconnect");
-    resolver_.reset();
-    if (!started_resolving_) {
-      grpc_closure_list_fail_all(&waiting_for_resolver_result_closures_,
-                                 GRPC_ERROR_REF(error));
-      GRPC_CLOSURE_LIST_SCHED(&waiting_for_resolver_result_closures_);
-    }
-    if (lb_policy_ != nullptr) {
-      grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
-                                       interested_parties_);
-      lb_policy_.reset();
-    }
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-grpc_connectivity_state RequestRouter::GetConnectivityState() {
-  return grpc_connectivity_state_check(&state_tracker_);
-}
-
-void RequestRouter::NotifyOnConnectivityStateChange(
-    grpc_connectivity_state* state, grpc_closure* closure) {
-  grpc_connectivity_state_notify_on_state_change(&state_tracker_, state,
-                                                 closure);
-}
-
-void RequestRouter::ExitIdleLocked() {
-  if (lb_policy_ != nullptr) {
-    lb_policy_->ExitIdleLocked();
-  } else {
-    exit_idle_when_lb_policy_arrives_ = true;
-    if (!started_resolving_ && resolver_ != nullptr) {
-      StartResolvingLocked();
-    }
-  }
-}
-
-void RequestRouter::ResetConnectionBackoffLocked() {
-  if (resolver_ != nullptr) {
-    resolver_->ResetBackoffLocked();
-    resolver_->RequestReresolutionLocked();
-  }
-  if (lb_policy_ != nullptr) {
-    lb_policy_->ResetBackoffLocked();
-  }
-}
-
-}  // namespace grpc_core

src/core/ext/filters/client_channel/request_routing.h

@@ -1,181 +0,0 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_REQUEST_ROUTING_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_REQUEST_ROUTING_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/client_channel_channelz.h"
-#include "src/core/ext/filters/client_channel/client_channel_factory.h"
-#include "src/core/ext/filters/client_channel/lb_policy.h"
-#include "src/core/ext/filters/client_channel/resolver.h"
-#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/call_combiner.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
-
-namespace grpc_core {
-
-class RequestRouter {
- public:
-  class Request {
-   public:
-    // Synchronous callback that applies the service config to a call.
-    // Returns false if the call should be failed.
-    typedef bool (*ApplyServiceConfigCallback)(void* user_data);
-
-    Request(grpc_call_stack* owning_call, grpc_call_combiner* call_combiner,
-            grpc_polling_entity* pollent,
-            grpc_metadata_batch* send_initial_metadata,
-            uint32_t* send_initial_metadata_flags,
-            ApplyServiceConfigCallback apply_service_config,
-            void* apply_service_config_user_data, grpc_closure* on_route_done);
-
-    ~Request();
-
-    // TODO(roth): It seems a bit ugly to expose this member in a
-    // non-const way.  Find a better API to avoid this.
-    LoadBalancingPolicy::PickState* pick() { return &pick_; }
-
-   private:
-    friend class RequestRouter;
-
-    class ResolverResultWaiter;
-    class AsyncPickCanceller;
-
-    void ProcessServiceConfigAndStartLbPickLocked();
-    void StartLbPickLocked();
-    static void LbPickDoneLocked(void* arg, grpc_error* error);
-
-    void MaybeAddCallToInterestedPartiesLocked();
-    void MaybeRemoveCallFromInterestedPartiesLocked();
-
-    // Populated by caller.
-    grpc_call_stack* owning_call_;
-    grpc_call_combiner* call_combiner_;
-    grpc_polling_entity* pollent_;
-    ApplyServiceConfigCallback apply_service_config_;
-    void* apply_service_config_user_data_;
-    grpc_closure* on_route_done_;
-    LoadBalancingPolicy::PickState pick_;
-
-    // Internal state.
-    RequestRouter* request_router_ = nullptr;
-    bool pollent_added_to_interested_parties_ = false;
-    grpc_closure on_pick_done_;
-    AsyncPickCanceller* pick_canceller_ = nullptr;
-  };
-
-  // Synchronous callback that takes the service config JSON string and
-  // LB policy name.
-  // Returns true if the service config has changed since the last result.
-  typedef bool (*ProcessResolverResultCallback)(void* user_data,
-                                                const grpc_channel_args& args,
-                                                const char** lb_policy_name,
-                                                grpc_json** lb_policy_config);
-
-  RequestRouter(grpc_channel_stack* owning_stack, grpc_combiner* combiner,
-                grpc_client_channel_factory* client_channel_factory,
-                grpc_pollset_set* interested_parties, TraceFlag* tracer,
-                ProcessResolverResultCallback process_resolver_result,
-                void* process_resolver_result_user_data, const char* target_uri,
-                const grpc_channel_args* args, grpc_error** error);
-
-  ~RequestRouter();
-
-  void set_channelz_node(channelz::ClientChannelNode* channelz_node) {
-    channelz_node_ = channelz_node;
-  }
-
-  void RouteCallLocked(Request* request);
-
-  // TODO(roth): Add methods to cancel picks.
-
-  void ShutdownLocked(grpc_error* error);
-
-  void ExitIdleLocked();
-  void ResetConnectionBackoffLocked();
-
-  grpc_connectivity_state GetConnectivityState();
-  void NotifyOnConnectivityStateChange(grpc_connectivity_state* state,
-                                       grpc_closure* closure);
-
-  LoadBalancingPolicy* lb_policy() const { return lb_policy_.get(); }
-
- private:
-  using TraceStringVector = InlinedVector<char*, 3>;
-
-  class ReresolutionRequestHandler;
-  class LbConnectivityWatcher;
-
-  void StartResolvingLocked();
-  void OnResolverShutdownLocked(grpc_error* error);
-  void CreateNewLbPolicyLocked(const char* lb_policy_name, grpc_json* lb_config,
-                               grpc_connectivity_state* connectivity_state,
-                               grpc_error** connectivity_error,
-                               TraceStringVector* trace_strings);
-  void MaybeAddTraceMessagesForAddressChangesLocked(
-      TraceStringVector* trace_strings);
-  void ConcatenateAndAddChannelTraceLocked(
-      TraceStringVector* trace_strings) const;
-  static void OnResolverResultChangedLocked(void* arg, grpc_error* error);
-
-  void SetConnectivityStateLocked(grpc_connectivity_state state,
-                                  grpc_error* error, const char* reason);
-
-  // Passed in from caller at construction time.
-  grpc_channel_stack* owning_stack_;
-  grpc_combiner* combiner_;
-  grpc_client_channel_factory* client_channel_factory_;
-  grpc_pollset_set* interested_parties_;
-  TraceFlag* tracer_;
-
-  channelz::ClientChannelNode* channelz_node_ = nullptr;
-
-  // Resolver and associated state.
-  OrphanablePtr<Resolver> resolver_;
-  ProcessResolverResultCallback process_resolver_result_;
-  void* process_resolver_result_user_data_;
-  bool started_resolving_ = false;
-  grpc_channel_args* resolver_result_ = nullptr;
-  bool previous_resolution_contained_addresses_ = false;
-  grpc_closure_list waiting_for_resolver_result_closures_;
-  grpc_closure on_resolver_result_changed_;
-
-  // LB policy and associated state.
-  OrphanablePtr<LoadBalancingPolicy> lb_policy_;
-  bool exit_idle_when_lb_policy_arrives_ = false;
-
-  // Subchannel pool to pass to LB policy.
-  RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
-
-  grpc_connectivity_state_tracker state_tracker_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_REQUEST_ROUTING_H */

src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -489,7 +489,7 @@ void grpc_resolver_dns_ares_init() {
     address_sorting_init();
     grpc_error* error = grpc_ares_init();
     if (error != GRPC_ERROR_NONE) {
-      GRPC_LOG_IF_ERROR("ares_library_init() failed", error);
+      GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
       return;
     }
     if (default_resolver == nullptr) {

src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -47,9 +47,6 @@
 using grpc_core::ServerAddress;
 using grpc_core::ServerAddressList;
 
-static gpr_once g_basic_init = GPR_ONCE_INIT;
-static gpr_mu g_init_mu;
-
 grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
                                                       "cares_address_sorting");
 
@@ -89,8 +86,6 @@ typedef struct grpc_ares_hostbyname_request {
   bool is_balancer;
 } grpc_ares_hostbyname_request;
 
-static void do_basic_init(void) { gpr_mu_init(&g_init_mu); }
-
 static void log_address_sorting_list(const ServerAddressList& addresses,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
@@ -588,12 +583,12 @@ static void grpc_cancel_ares_request_locked_impl(grpc_ares_request* r) {
 void (*grpc_cancel_ares_request_locked)(grpc_ares_request* r) =
     grpc_cancel_ares_request_locked_impl;
 
+// ares_library_init and ares_library_cleanup are currently no-op except under
+// Windows. Calling them may cause race conditions when other parts of the
+// binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
 grpc_error* grpc_ares_init(void) {
-  gpr_once_init(&g_basic_init, do_basic_init);
-  gpr_mu_lock(&g_init_mu);
   int status = ares_library_init(ARES_LIB_INIT_ALL);
-  gpr_mu_unlock(&g_init_mu);
-
   if (status != ARES_SUCCESS) {
     char* error_msg;
     gpr_asprintf(&error_msg, "ares_library_init failed: %s",
@@ -605,11 +600,11 @@ grpc_error* grpc_ares_init(void) {
   return GRPC_ERROR_NONE;
 }
 
-void grpc_ares_cleanup(void) {
-  gpr_mu_lock(&g_init_mu);
-  ares_library_cleanup();
-  gpr_mu_unlock(&g_init_mu);
-}
+void grpc_ares_cleanup(void) { ares_library_cleanup(); }
+#else
+grpc_error* grpc_ares_init(void) { return GRPC_ERROR_NONE; }
+void grpc_ares_cleanup(void) {}
+#endif  // GPR_WINDOWS
 
 /*
  * grpc_resolve_address_ares related structs and functions

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

@@ -148,7 +148,8 @@ void ProcessedResolverResult::ParseLbConfigFromServiceConfig(
       LoadBalancingPolicy::ParseLoadBalancingConfig(field);
   if (policy != nullptr) {
     lb_policy_name_.reset(gpr_strdup(policy->key));
-    lb_policy_config_ = policy->child;
+    lb_policy_config_ = MakeRefCounted<LoadBalancingPolicy::Config>(
+        policy->child, service_config_);
   }
 }
 

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -60,7 +61,9 @@ class ProcessedResolverResult {
     return std::move(method_params_table_);
   }
   UniquePtr<char> lb_policy_name() { return std::move(lb_policy_name_); }
-  grpc_json* lb_policy_config() { return lb_policy_config_; }
+  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config() {
+    return std::move(lb_policy_config_);
+  }
 
  private:
   // Finds the service config; extracts LB config and (maybe) retry throttle
@@ -82,10 +85,10 @@ class ProcessedResolverResult {
 
   // Service config.
   UniquePtr<char> service_config_json_;
-  UniquePtr<grpc_core::ServiceConfig> service_config_;
+  RefCountedPtr<ServiceConfig> service_config_;
   // LB policy.
-  grpc_json* lb_policy_config_ = nullptr;
   UniquePtr<char> lb_policy_name_;
+  RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config_;
   // Retry throttle data.
   char* server_name_ = nullptr;
   RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;

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

@@ -0,0 +1,454 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/resolving_lb_policy.h"
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+
+#include "src/core/ext/filters/client_channel/backup_poller.h"
+#include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
+#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
+#include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/retry_throttle.h"
+#include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/ext/filters/deadline/deadline_filter.h"
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/connected_channel.h"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/service_config.h"
+#include "src/core/lib/transport/static_metadata.h"
+#include "src/core/lib/transport/status_metadata.h"
+
+namespace grpc_core {
+
+//
+// ResolvingLoadBalancingPolicy::ResolvingControlHelper
+//
+
+class ResolvingLoadBalancingPolicy::ResolvingControlHelper
+    : public LoadBalancingPolicy::ChannelControlHelper {
+ public:
+  explicit ResolvingControlHelper(
+      RefCountedPtr<ResolvingLoadBalancingPolicy> parent)
+      : parent_(std::move(parent)) {}
+
+  Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
+    if (parent_->resolver_ == nullptr) return nullptr;  // Shutting down.
+    return parent_->channel_control_helper()->CreateSubchannel(args);
+  }
+
+  grpc_channel* CreateChannel(const char* target, grpc_client_channel_type type,
+                              const grpc_channel_args& args) override {
+    if (parent_->resolver_ == nullptr) return nullptr;  // Shutting down.
+    return parent_->channel_control_helper()->CreateChannel(target, type, args);
+  }
+
+  void UpdateState(grpc_connectivity_state state, grpc_error* state_error,
+                   UniquePtr<SubchannelPicker> picker) override {
+    if (parent_->resolver_ == nullptr) {
+      // shutting down.
+      GRPC_ERROR_UNREF(state_error);
+      return;
+    }
+    parent_->channel_control_helper()->UpdateState(state, state_error,
+                                                   std::move(picker));
+  }
+
+  void RequestReresolution() override {
+    if (parent_->tracer_->enabled()) {
+      gpr_log(GPR_INFO, "resolving_lb=%p: started name re-resolving",
+              parent_.get());
+    }
+    if (parent_->resolver_ != nullptr) {
+      parent_->resolver_->RequestReresolutionLocked();
+    }
+  }
+
+ private:
+  RefCountedPtr<ResolvingLoadBalancingPolicy> parent_;
+};
+
+//
+// ResolvingLoadBalancingPolicy
+//
+
+ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
+    Args args, TraceFlag* tracer, UniquePtr<char> target_uri,
+    UniquePtr<char> child_policy_name, RefCountedPtr<Config> child_lb_config,
+    grpc_error** error)
+    : LoadBalancingPolicy(std::move(args)),
+      tracer_(tracer),
+      target_uri_(std::move(target_uri)),
+      child_policy_name_(std::move(child_policy_name)),
+      child_lb_config_(std::move(child_lb_config)) {
+  GPR_ASSERT(child_policy_name_ != nullptr);
+  // Don't fetch service config, since this ctor is for use in nested LB
+  // policies, not at the top level, and we only fetch the service
+  // config at the top level.
+  grpc_arg arg = grpc_channel_arg_integer_create(
+      const_cast<char*>(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION), 0);
+  grpc_channel_args* new_args =
+      grpc_channel_args_copy_and_add(args.args, &arg, 1);
+  *error = Init(*new_args);
+  grpc_channel_args_destroy(new_args);
+}
+
+ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
+    Args args, TraceFlag* tracer, UniquePtr<char> target_uri,
+    ProcessResolverResultCallback process_resolver_result,
+    void* process_resolver_result_user_data, grpc_error** error)
+    : LoadBalancingPolicy(std::move(args)),
+      tracer_(tracer),
+      target_uri_(std::move(target_uri)),
+      process_resolver_result_(process_resolver_result),
+      process_resolver_result_user_data_(process_resolver_result_user_data) {
+  GPR_ASSERT(process_resolver_result != nullptr);
+  *error = Init(*args.args);
+}
+
+grpc_error* ResolvingLoadBalancingPolicy::Init(const grpc_channel_args& args) {
+  GRPC_CLOSURE_INIT(
+      &on_resolver_result_changed_,
+      &ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked, this,
+      grpc_combiner_scheduler(combiner()));
+  resolver_ = ResolverRegistry::CreateResolver(
+      target_uri_.get(), &args, interested_parties(), combiner());
+  if (resolver_ == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("resolver creation failed");
+  }
+  // Return our picker to the channel.
+  channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_IDLE, GRPC_ERROR_NONE,
+      UniquePtr<SubchannelPicker>(New<QueuePicker>(Ref())));
+  return GRPC_ERROR_NONE;
+}
+
+ResolvingLoadBalancingPolicy::~ResolvingLoadBalancingPolicy() {
+  GPR_ASSERT(resolver_ == nullptr);
+  GPR_ASSERT(lb_policy_ == nullptr);
+}
+
+void ResolvingLoadBalancingPolicy::ShutdownLocked() {
+  if (resolver_ != nullptr) {
+    resolver_.reset();
+    if (lb_policy_ != nullptr) {
+      grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
+                                       interested_parties());
+      lb_policy_.reset();
+    }
+  }
+}
+
+void ResolvingLoadBalancingPolicy::ExitIdleLocked() {
+  if (lb_policy_ != nullptr) {
+    lb_policy_->ExitIdleLocked();
+  } else {
+    if (!started_resolving_ && resolver_ != nullptr) {
+      StartResolvingLocked();
+    }
+  }
+}
+
+void ResolvingLoadBalancingPolicy::ResetBackoffLocked() {
+  if (resolver_ != nullptr) {
+    resolver_->ResetBackoffLocked();
+    resolver_->RequestReresolutionLocked();
+  }
+  if (lb_policy_ != nullptr) {
+    lb_policy_->ResetBackoffLocked();
+  }
+}
+
+void ResolvingLoadBalancingPolicy::FillChildRefsForChannelz(
+    channelz::ChildRefsList* child_subchannels,
+    channelz::ChildRefsList* child_channels) {
+  if (lb_policy_ != nullptr) {
+    lb_policy_->FillChildRefsForChannelz(child_subchannels, child_channels);
+  }
+}
+
+void ResolvingLoadBalancingPolicy::StartResolvingLocked() {
+  if (tracer_->enabled()) {
+    gpr_log(GPR_INFO, "resolving_lb=%p: starting name resolution", this);
+  }
+  GPR_ASSERT(!started_resolving_);
+  started_resolving_ = true;
+  channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_CONNECTING, GRPC_ERROR_NONE,
+      UniquePtr<SubchannelPicker>(New<QueuePicker>(Ref())));
+  Ref().release();
+  resolver_->NextLocked(&resolver_result_, &on_resolver_result_changed_);
+}
+
+// Invoked from the resolver NextLocked() callback when the resolver
+// is shutting down.
+void ResolvingLoadBalancingPolicy::OnResolverShutdownLocked(grpc_error* error) {
+  if (tracer_->enabled()) {
+    gpr_log(GPR_INFO, "resolving_lb=%p: shutting down", this);
+  }
+  if (lb_policy_ != nullptr) {
+    if (tracer_->enabled()) {
+      gpr_log(GPR_INFO, "resolving_lb=%p: shutting down lb_policy=%p", this,
+              lb_policy_.get());
+    }
+    grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
+                                     interested_parties());
+    lb_policy_.reset();
+  }
+  if (resolver_ != nullptr) {
+    // This should never happen; it can only be triggered by a resolver
+    // implementation spotaneously deciding to report shutdown without
+    // being orphaned.  This code is included just to be defensive.
+    if (tracer_->enabled()) {
+      gpr_log(GPR_INFO,
+              "resolving_lb=%p: spontaneous shutdown from resolver %p", this,
+              resolver_.get());
+    }
+    resolver_.reset();
+    grpc_error* error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+        "Resolver spontaneous shutdown", &error, 1);
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(error),
+        UniquePtr<SubchannelPicker>(New<TransientFailurePicker>(error)));
+  }
+  grpc_channel_args_destroy(resolver_result_);
+  resolver_result_ = nullptr;
+  GRPC_ERROR_UNREF(error);
+  Unref();
+}
+
+// Creates a new LB policy, replacing any previous one.
+// Updates trace_strings to indicate what was done.
+void ResolvingLoadBalancingPolicy::CreateNewLbPolicyLocked(
+    const char* lb_policy_name, TraceStringVector* trace_strings) {
+  LoadBalancingPolicy::Args lb_policy_args;
+  lb_policy_args.combiner = combiner();
+  lb_policy_args.channel_control_helper =
+      UniquePtr<ChannelControlHelper>(New<ResolvingControlHelper>(Ref()));
+  lb_policy_args.args = resolver_result_;
+  OrphanablePtr<LoadBalancingPolicy> new_lb_policy =
+      LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
+          lb_policy_name, std::move(lb_policy_args));
+  if (GPR_UNLIKELY(new_lb_policy == nullptr)) {
+    gpr_log(GPR_ERROR, "could not create LB policy \"%s\"", lb_policy_name);
+    if (channelz_node() != nullptr) {
+      char* str;
+      gpr_asprintf(&str, "Could not create LB policy \"%s\"", lb_policy_name);
+      trace_strings->push_back(str);
+    }
+  } else {
+    if (tracer_->enabled()) {
+      gpr_log(GPR_INFO, "resolving_lb=%p: created new LB policy \"%s\" (%p)",
+              this, lb_policy_name, new_lb_policy.get());
+    }
+    if (channelz_node() != nullptr) {
+      char* str;
+      gpr_asprintf(&str, "Created new LB policy \"%s\"", lb_policy_name);
+      trace_strings->push_back(str);
+    }
+    // Propagate channelz node.
+    auto* channelz = channelz_node();
+    if (channelz != nullptr) {
+      new_lb_policy->set_channelz_node(channelz->Ref());
+    }
+    // Swap out the LB policy and update the fds in interested_parties_.
+    if (lb_policy_ != nullptr) {
+      if (tracer_->enabled()) {
+        gpr_log(GPR_INFO, "resolving_lb=%p: shutting down lb_policy=%p", this,
+                lb_policy_.get());
+      }
+      grpc_pollset_set_del_pollset_set(lb_policy_->interested_parties(),
+                                       interested_parties());
+    }
+    lb_policy_ = std::move(new_lb_policy);
+    grpc_pollset_set_add_pollset_set(lb_policy_->interested_parties(),
+                                     interested_parties());
+  }
+}
+
+void ResolvingLoadBalancingPolicy::MaybeAddTraceMessagesForAddressChangesLocked(
+    TraceStringVector* trace_strings) {
+  const ServerAddressList* addresses =
+      FindServerAddressListChannelArg(resolver_result_);
+  const bool resolution_contains_addresses =
+      addresses != nullptr && addresses->size() > 0;
+  if (!resolution_contains_addresses &&
+      previous_resolution_contained_addresses_) {
+    trace_strings->push_back(gpr_strdup("Address list became empty"));
+  } else if (resolution_contains_addresses &&
+             !previous_resolution_contained_addresses_) {
+    trace_strings->push_back(gpr_strdup("Address list became non-empty"));
+  }
+  previous_resolution_contained_addresses_ = resolution_contains_addresses;
+}
+
+void ResolvingLoadBalancingPolicy::ConcatenateAndAddChannelTraceLocked(
+    TraceStringVector* trace_strings) const {
+  if (!trace_strings->empty()) {
+    gpr_strvec v;
+    gpr_strvec_init(&v);
+    gpr_strvec_add(&v, gpr_strdup("Resolution event: "));
+    bool is_first = 1;
+    for (size_t i = 0; i < trace_strings->size(); ++i) {
+      if (!is_first) gpr_strvec_add(&v, gpr_strdup(", "));
+      is_first = false;
+      gpr_strvec_add(&v, (*trace_strings)[i]);
+    }
+    char* flat;
+    size_t flat_len = 0;
+    flat = gpr_strvec_flatten(&v, &flat_len);
+    channelz_node()->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
+                                   grpc_slice_new(flat, flat_len, gpr_free));
+    gpr_strvec_destroy(&v);
+  }
+}
+
+// Callback invoked when a resolver result is available.
+void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
+    void* arg, grpc_error* error) {
+  auto* self = static_cast<ResolvingLoadBalancingPolicy*>(arg);
+  if (self->tracer_->enabled()) {
+    const char* disposition =
+        self->resolver_result_ != nullptr
+            ? ""
+            : (error == GRPC_ERROR_NONE ? " (transient error)"
+                                        : " (resolver shutdown)");
+    gpr_log(GPR_INFO,
+            "resolving_lb=%p: got resolver result: resolver_result=%p "
+            "error=%s%s",
+            self, self->resolver_result_, grpc_error_string(error),
+            disposition);
+  }
+  // Handle shutdown.
+  if (error != GRPC_ERROR_NONE || self->resolver_ == nullptr) {
+    self->OnResolverShutdownLocked(GRPC_ERROR_REF(error));
+    return;
+  }
+  // We only want to trace the address resolution in the follow cases:
+  // (a) Address resolution resulted in service config change.
+  // (b) Address resolution that causes number of backends to go from
+  //     zero to non-zero.
+  // (c) Address resolution that causes number of backends to go from
+  //     non-zero to zero.
+  // (d) Address resolution that causes a new LB policy to be created.
+  //
+  // we track a list of strings to eventually be concatenated and traced.
+  TraceStringVector trace_strings;
+  // resolver_result_ will be null in the case of a transient
+  // resolution error.  In that case, we don't have any new result to
+  // process, which means that we keep using the previous result (if any).
+  if (self->resolver_result_ == nullptr) {
+    if (self->tracer_->enabled()) {
+      gpr_log(GPR_INFO, "resolving_lb=%p: resolver transient failure", self);
+    }
+    // If we already have an LB policy from a previous resolution
+    // result, then we continue to let it set the connectivity state.
+    // Otherwise, we go into TRANSIENT_FAILURE.
+    if (self->lb_policy_ == nullptr) {
+      // TODO(roth): When we change the resolver API to be able to
+      // return transient errors in a cleaner way, we should make it the
+      // resolver's responsibility to attach a status to the error,
+      // rather than doing it centrally here.
+      grpc_error* state_error = grpc_error_set_int(
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+              "Resolver transient failure", &error, 1),
+          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+      self->channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_TRANSIENT_FAILURE, GRPC_ERROR_REF(state_error),
+          UniquePtr<SubchannelPicker>(
+              New<TransientFailurePicker>(state_error)));
+    }
+  } else {
+    // Parse the resolver result.
+    const char* lb_policy_name = nullptr;
+    RefCountedPtr<Config> lb_policy_config;
+    bool service_config_changed = false;
+    if (self->process_resolver_result_ != nullptr) {
+      service_config_changed = self->process_resolver_result_(
+          self->process_resolver_result_user_data_, *self->resolver_result_,
+          &lb_policy_name, &lb_policy_config);
+    } else {
+      lb_policy_name = self->child_policy_name_.get();
+      lb_policy_config = self->child_lb_config_;
+    }
+    GPR_ASSERT(lb_policy_name != nullptr);
+    // If we're not already using the right LB policy name, instantiate
+    // a new one.
+    if (self->lb_policy_ == nullptr ||
+        strcmp(self->lb_policy_->name(), lb_policy_name) != 0) {
+      if (self->tracer_->enabled()) {
+        gpr_log(GPR_INFO, "resolving_lb=%p: creating new LB policy \"%s\"",
+                self, lb_policy_name);
+      }
+      self->CreateNewLbPolicyLocked(lb_policy_name, &trace_strings);
+    }
+    // Update the LB policy with the new addresses and config.
+    if (self->tracer_->enabled()) {
+      gpr_log(GPR_INFO, "resolving_lb=%p: updating LB policy \"%s\" (%p)", self,
+              lb_policy_name, self->lb_policy_.get());
+    }
+    self->lb_policy_->UpdateLocked(*self->resolver_result_,
+                                   std::move(lb_policy_config));
+    // Add channel trace event.
+    if (self->channelz_node() != nullptr) {
+      if (service_config_changed) {
+        // TODO(ncteisen): might be worth somehow including a snippet of the
+        // config in the trace, at the risk of bloating the trace logs.
+        trace_strings.push_back(gpr_strdup("Service config changed"));
+      }
+      self->MaybeAddTraceMessagesForAddressChangesLocked(&trace_strings);
+      self->ConcatenateAndAddChannelTraceLocked(&trace_strings);
+    }
+    // Clean up.
+    grpc_channel_args_destroy(self->resolver_result_);
+    self->resolver_result_ = nullptr;
+  }
+  // Renew resolver callback.
+  self->resolver_->NextLocked(&self->resolver_result_,
+                              &self->on_resolver_result_changed_);
+}
+
+}  // namespace grpc_core

src/core/ext/filters/client_channel/resolving_lb_policy.h

@@ -0,0 +1,134 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVING_LB_POLICY_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVING_LB_POLICY_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/ext/filters/client_channel/lb_policy.h"
+#include "src/core/ext/filters/client_channel/resolver.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// An LB policy that wraps a resolver and a child LB policy to make use
+// of the addresses returned by the resolver.
+//
+// When used in the client_channel code, the resolver will attempt to
+// fetch the service config, and the child LB policy name and config
+// will be determined based on the service config.
+//
+// When used in an LB policy implementation that needs to do another
+// round of resolution before creating a child policy, the resolver does
+// not fetch the service config, and the caller must pre-determine the
+// child LB policy and config to use.
+class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
+ public:
+  // If error is set when this returns, then construction failed, and
+  // the caller may not use the new object.
+  ResolvingLoadBalancingPolicy(Args args, TraceFlag* tracer,
+                               UniquePtr<char> target_uri,
+                               UniquePtr<char> child_policy_name,
+                               RefCountedPtr<Config> child_lb_config,
+                               grpc_error** error);
+
+  // Private ctor, to be used by client_channel only!
+  //
+  // Synchronous callback that takes the resolver result and sets
+  // lb_policy_name and lb_policy_config to point to the right data.
+  // Returns true if the service config has changed since the last result.
+  typedef bool (*ProcessResolverResultCallback)(
+      void* user_data, const grpc_channel_args& args,
+      const char** lb_policy_name, RefCountedPtr<Config>* lb_policy_config);
+  // If error is set when this returns, then construction failed, and
+  // the caller may not use the new object.
+  ResolvingLoadBalancingPolicy(
+      Args args, TraceFlag* tracer, UniquePtr<char> target_uri,
+      ProcessResolverResultCallback process_resolver_result,
+      void* process_resolver_result_user_data, grpc_error** error);
+
+  virtual const char* name() const override { return "resolving_lb"; }
+
+  // No-op -- should never get updates from the channel.
+  // TODO(roth): Need to support updating child LB policy's config for xds
+  // use case.
+  void UpdateLocked(const grpc_channel_args& args,
+                    RefCountedPtr<Config> lb_config) override {}
+
+  void ExitIdleLocked() override;
+
+  void ResetBackoffLocked() override;
+
+  void FillChildRefsForChannelz(
+      channelz::ChildRefsList* child_subchannels,
+      channelz::ChildRefsList* child_channels) override;
+
+ private:
+  using TraceStringVector = InlinedVector<char*, 3>;
+
+  class ResolvingControlHelper;
+
+  ~ResolvingLoadBalancingPolicy();
+
+  grpc_error* Init(const grpc_channel_args& args);
+  void ShutdownLocked() override;
+
+  void StartResolvingLocked();
+  void OnResolverShutdownLocked(grpc_error* error);
+  void CreateNewLbPolicyLocked(const char* lb_policy_name,
+                               TraceStringVector* trace_strings);
+  void MaybeAddTraceMessagesForAddressChangesLocked(
+      TraceStringVector* trace_strings);
+  void ConcatenateAndAddChannelTraceLocked(
+      TraceStringVector* trace_strings) const;
+  static void OnResolverResultChangedLocked(void* arg, grpc_error* error);
+
+  // Passed in from caller at construction time.
+  TraceFlag* tracer_;
+  UniquePtr<char> target_uri_;
+  ProcessResolverResultCallback process_resolver_result_ = nullptr;
+  void* process_resolver_result_user_data_ = nullptr;
+  UniquePtr<char> child_policy_name_;
+  RefCountedPtr<Config> child_lb_config_;
+
+  // Resolver and associated state.
+  OrphanablePtr<Resolver> resolver_;
+  bool started_resolving_ = false;
+  grpc_channel_args* resolver_result_ = nullptr;
+  bool previous_resolution_contained_addresses_ = false;
+  grpc_closure on_resolver_result_changed_;
+
+  // Child LB policy and associated state.
+  OrphanablePtr<LoadBalancingPolicy> lb_policy_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVING_LB_POLICY_H */

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

@@ -590,7 +590,7 @@ Subchannel::Subchannel(SubchannelKey* key, grpc_connector* connector,
   const char* service_config_json = grpc_channel_arg_get_string(
       grpc_channel_args_find(args_, GRPC_ARG_SERVICE_CONFIG));
   if (service_config_json != nullptr) {
-    UniquePtr<ServiceConfig> service_config =
+    RefCountedPtr<ServiceConfig> service_config =
         ServiceConfig::Create(service_config_json);
     if (service_config != nullptr) {
       HealthCheckParams params;
@@ -956,22 +956,17 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
   } else if (c->disconnected_) {
     GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
   } else {
-    c->SetConnectivityStateLocked(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
-        grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                               "Connect Failed", &error, 1),
-                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
-        "connect_failed");
-    grpc_connectivity_state_set(
-        &c->state_and_health_tracker_, GRPC_CHANNEL_TRANSIENT_FAILURE,
-        grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                               "Connect Failed", &error, 1),
-                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
-        "connect_failed");
-
     const char* errmsg = grpc_error_string(error);
     gpr_log(GPR_INFO, "Connect failed: %s", errmsg);
-
+    error =
+        grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                               "Connect Failed", &error, 1),
+                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+    c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                  GRPC_ERROR_REF(error), "connect_failed");
+    grpc_connectivity_state_set(&c->state_and_health_tracker_,
+                                GRPC_CHANNEL_TRANSIENT_FAILURE, error,
+                                "connect_failed");
     c->MaybeStartConnectingLocked();
     GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
   }

src/core/ext/filters/load_reporting/server_load_reporting_filter.cc

@@ -342,8 +342,8 @@ bool MaybeAddServerLoadReportingFilter(const grpc_channel_args& args) {
 // time if we build with the filter target.
 struct ServerLoadReportingFilterStaticRegistrar {
   ServerLoadReportingFilterStaticRegistrar() {
-    static std::atomic_bool registered{false};
-    if (registered) return;
+    static grpc_core::Atomic<bool> registered{false};
+    if (registered.Load(grpc_core::MemoryOrder::ACQUIRE)) return;
     RegisterChannelFilter<ServerLoadReportingChannelData,
                           ServerLoadReportingCallData>(
         "server_load_reporting", GRPC_SERVER_CHANNEL, INT_MAX,
@@ -356,7 +356,7 @@ struct ServerLoadReportingFilterStaticRegistrar {
     ::grpc::load_reporter::MeasureEndBytesReceived();
     ::grpc::load_reporter::MeasureEndLatencyMs();
     ::grpc::load_reporter::MeasureOtherCallMetric();
-    registered = true;
+    registered.Store(true, grpc_core::MemoryOrder::RELEASE);
   }
 } server_load_reporting_filter_static_registrar;
 

src/core/ext/filters/message_size/message_size_filter.cc

@@ -319,7 +319,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
       grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG);
   const char* service_config_str = grpc_channel_arg_get_string(channel_arg);
   if (service_config_str != nullptr) {
-    grpc_core::UniquePtr<grpc_core::ServiceConfig> service_config =
+    grpc_core::RefCountedPtr<grpc_core::ServiceConfig> service_config =
         grpc_core::ServiceConfig::Create(service_config_str);
     if (service_config != nullptr) {
       chand->method_limit_table = service_config->CreateMethodConfigTable(

src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -1452,7 +1452,7 @@ static grpc_error* begin_parse_string(grpc_chttp2_hpack_parser* p,
                                       uint8_t binary,
                                       grpc_chttp2_hpack_parser_string* str) {
   if (!p->huff && binary == NOT_BINARY &&
-      (end - cur) >= static_cast<intptr_t>(p->strlen) &&
+      static_cast<uint32_t>(end - cur) >= p->strlen &&
       p->current_slice_refcount != nullptr) {
     GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED();
     str->copied = false;

src/core/ext/transport/inproc/inproc_transport.cc

@@ -1032,6 +1032,11 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
     }
   } else {
     if (error != GRPC_ERROR_NONE) {
+      // Consume any send message that was sent here but that we are not pushing
+      // to the other side
+      if (op->send_message) {
+        op->payload->send_message.send_message.reset();
+      }
       // Schedule op's closures that we didn't push to op state machine
       if (op->recv_initial_metadata) {
         if (op->payload->recv_initial_metadata.trailing_metadata_available !=

src/core/lib/channel/channelz.cc

@@ -385,52 +385,65 @@ grpc_json* SocketNode::RenderJson() {
   json = data;
   json_iterator = nullptr;
   gpr_timespec ts;
-  if (streams_started_ != 0) {
+  gpr_atm streams_started = gpr_atm_no_barrier_load(&streams_started_);
+  if (streams_started != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsStarted", streams_started_);
-    if (last_local_stream_created_millis_ != 0) {
-      ts = grpc_millis_to_timespec(last_local_stream_created_millis_,
+        json, json_iterator, "streamsStarted", streams_started);
+    gpr_atm last_local_stream_created_millis =
+        gpr_atm_no_barrier_load(&last_local_stream_created_millis_);
+    if (last_local_stream_created_millis != 0) {
+      ts = grpc_millis_to_timespec(last_local_stream_created_millis,
                                    GPR_CLOCK_REALTIME);
       json_iterator = grpc_json_create_child(
           json_iterator, json, "lastLocalStreamCreatedTimestamp",
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
-    if (last_remote_stream_created_millis_ != 0) {
-      ts = grpc_millis_to_timespec(last_remote_stream_created_millis_,
+    gpr_atm last_remote_stream_created_millis =
+        gpr_atm_no_barrier_load(&last_remote_stream_created_millis_);
+    if (last_remote_stream_created_millis != 0) {
+      ts = grpc_millis_to_timespec(last_remote_stream_created_millis,
                                    GPR_CLOCK_REALTIME);
       json_iterator = grpc_json_create_child(
           json_iterator, json, "lastRemoteStreamCreatedTimestamp",
           gpr_format_timespec(ts), GRPC_JSON_STRING, true);
     }
   }
-  if (streams_succeeded_ != 0) {
+  gpr_atm streams_succeeded = gpr_atm_no_barrier_load(&streams_succeeded_);
+  if (streams_succeeded != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsSucceeded", streams_succeeded_);
+        json, json_iterator, "streamsSucceeded", streams_succeeded);
   }
-  if (streams_failed_) {
+  gpr_atm streams_failed = gpr_atm_no_barrier_load(&streams_failed_);
+  if (streams_failed) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "streamsFailed", streams_failed_);
+        json, json_iterator, "streamsFailed", streams_failed);
   }
-  if (messages_sent_ != 0) {
+  gpr_atm messages_sent = gpr_atm_no_barrier_load(&messages_sent_);
+  if (messages_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "messagesSent", messages_sent_);
-    ts = grpc_millis_to_timespec(last_message_sent_millis_, GPR_CLOCK_REALTIME);
+        json, json_iterator, "messagesSent", messages_sent);
+    ts = grpc_millis_to_timespec(
+        gpr_atm_no_barrier_load(&last_message_sent_millis_),
+        GPR_CLOCK_REALTIME);
     json_iterator =
         grpc_json_create_child(json_iterator, json, "lastMessageSentTimestamp",
                                gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  if (messages_received_ != 0) {
+  gpr_atm messages_received = gpr_atm_no_barrier_load(&messages_received_);
+  if (messages_received != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "messagesReceived", messages_received_);
-    ts = grpc_millis_to_timespec(last_message_received_millis_,
-                                 GPR_CLOCK_REALTIME);
+        json, json_iterator, "messagesReceived", messages_received);
+    ts = grpc_millis_to_timespec(
+        gpr_atm_no_barrier_load(&last_message_received_millis_),
+        GPR_CLOCK_REALTIME);
     json_iterator = grpc_json_create_child(
         json_iterator, json, "lastMessageReceivedTimestamp",
         gpr_format_timespec(ts), GRPC_JSON_STRING, true);
   }
-  if (keepalives_sent_ != 0) {
+  gpr_atm keepalives_sent = gpr_atm_no_barrier_load(&keepalives_sent_);
+  if (keepalives_sent != 0) {
     json_iterator = grpc_json_add_number_string_child(
-        json, json_iterator, "keepAlivesSent", keepalives_sent_);
+        json, json_iterator, "keepAlivesSent", keepalives_sent);
   }
   return top_level_json;
 }

src/core/lib/gpr/sync_posix.cc

@@ -76,7 +76,7 @@ gpr_atm gpr_counter_atm_add = 0;
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_mutex_init(&mu->mutex, nullptr) == 0);
-  mu->leak_checker = static_cast<int*>(gpr_malloc(sizeof(*mu->leak_checker)));
+  mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
   GPR_ASSERT(mu->leak_checker != nullptr);
 #else
   GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
@@ -86,7 +86,7 @@ void gpr_mu_init(gpr_mu* mu) {
 void gpr_mu_destroy(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_mutex_destroy(&mu->mutex) == 0);
-  gpr_free(mu->leak_checker);
+  free(mu->leak_checker);
 #else
   GPR_ASSERT(pthread_mutex_destroy(mu) == 0);
 #endif
@@ -136,7 +136,7 @@ void gpr_cv_init(gpr_cv* cv) {
 
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_cond_init(&cv->cond_var, &attr) == 0);
-  cv->leak_checker = static_cast<int*>(gpr_malloc(sizeof(*cv->leak_checker)));
+  cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
   GPR_ASSERT(cv->leak_checker != nullptr);
 #else
   GPR_ASSERT(pthread_cond_init(cv, &attr) == 0);
@@ -146,7 +146,7 @@ void gpr_cv_init(gpr_cv* cv) {
 void gpr_cv_destroy(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_cond_destroy(&cv->cond_var) == 0);
-  gpr_free(cv->leak_checker);
+  free(cv->leak_checker);
 #else
   GPR_ASSERT(pthread_cond_destroy(cv) == 0);
 #endif

src/core/lib/gprpp/atomic.h

@@ -21,10 +21,80 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GPR_HAS_CXX11_ATOMIC
-#include "src/core/lib/gprpp/atomic_with_std.h"
-#else
-#include "src/core/lib/gprpp/atomic_with_atm.h"
-#endif
+#include <atomic>
+
+#include <grpc/support/atm.h>
+
+namespace grpc_core {
+
+enum class MemoryOrder {
+  RELAXED = std::memory_order_relaxed,
+  CONSUME = std::memory_order_consume,
+  ACQUIRE = std::memory_order_acquire,
+  RELEASE = std::memory_order_release,
+  ACQ_REL = std::memory_order_acq_rel,
+  SEQ_CST = std::memory_order_seq_cst
+};
+
+template <typename T>
+class Atomic {
+ public:
+  explicit Atomic(T val = T()) : storage_(val) {}
+
+  T Load(MemoryOrder order) const {
+    return storage_.load(static_cast<std::memory_order>(order));
+  }
+
+  void Store(T val, MemoryOrder order) {
+    storage_.store(val, static_cast<std::memory_order>(order));
+  }
+
+  bool CompareExchangeWeak(T* expected, T desired, MemoryOrder success,
+                           MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(
+        storage_.compare_exchange_weak(*expected, desired, success, failure));
+  }
+
+  bool CompareExchangeStrong(T* expected, T desired, MemoryOrder success,
+                             MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(storage_.compare_exchange_weak(
+        *expected, desired, static_cast<std::memory_order>(success),
+        static_cast<std::memory_order>(failure)));
+  }
+
+  template <typename Arg>
+  T FetchAdd(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_add(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  template <typename Arg>
+  T FetchSub(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_sub(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  // Atomically increment a counter only if the counter value is not zero.
+  // Returns true if increment took place; false if counter is zero.
+  bool IncrementIfNonzero(MemoryOrder load_order = MemoryOrder::ACQ_REL) {
+    T count = storage_.load(static_cast<std::memory_order>(load_order));
+    do {
+      // If zero, we are done (without an increment). If not, we must do a CAS
+      // to maintain the contract: do not increment the counter if it is already
+      // zero
+      if (count == 0) {
+        return false;
+      }
+    } while (!storage_.AtomicCompareExchangeWeak(
+        &count, count + 1, static_cast<std::memory_order>(MemoryOrder::ACQ_REL),
+        static_cast<std::memory_order>(load_order)));
+    return true;
+  }
+
+ private:
+  std::atomic<T> storage_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_H */

src/core/lib/gprpp/atomic_with_atm.h

@@ -1,57 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H
-#define GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/atm.h>
-
-namespace grpc_core {
-
-enum MemoryOrderRelaxed { memory_order_relaxed };
-
-template <class T>
-class atomic;
-
-template <>
-class atomic<bool> {
- public:
-  atomic() { gpr_atm_no_barrier_store(&x_, static_cast<gpr_atm>(false)); }
-  explicit atomic(bool x) {
-    gpr_atm_no_barrier_store(&x_, static_cast<gpr_atm>(x));
-  }
-
-  bool compare_exchange_strong(bool& expected, bool update, MemoryOrderRelaxed,
-                               MemoryOrderRelaxed) {
-    if (!gpr_atm_no_barrier_cas(&x_, static_cast<gpr_atm>(expected),
-                                static_cast<gpr_atm>(update))) {
-      expected = gpr_atm_no_barrier_load(&x_) != 0;
-      return false;
-    }
-    return true;
-  }
-
- private:
-  gpr_atm x_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H */

src/core/lib/gprpp/atomic_with_std.h

@@ -1,35 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H
-#define GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H
-
-#include <grpc/support/port_platform.h>
-
-#include <atomic>
-
-namespace grpc_core {
-
-template <class T>
-using atomic = std::atomic<T>;
-
-typedef std::memory_order memory_order;
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_STD_H */

src/core/lib/gprpp/orphanable.h

@@ -94,8 +94,9 @@ class InternallyRefCounted : public Orphanable {
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
   template <typename TraceFlagT = TraceFlag>
-  explicit InternallyRefCounted(TraceFlagT* trace_flag = nullptr)
-      : refs_(1, trace_flag) {}
+  explicit InternallyRefCounted(TraceFlagT* trace_flag = nullptr,
+                                intptr_t initial_refcount = 1)
+      : refs_(initial_refcount, trace_flag) {}
   virtual ~InternallyRefCounted() = default;
 
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {

src/core/lib/gprpp/ref_counted.h

@@ -31,6 +31,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -88,9 +89,7 @@ class RefCount {
   }
 
   // Increases the ref-count by `n`.
-  void Ref(Value n = 1) {
-    GPR_ATM_INC_ADD_THEN(value_.fetch_add(n, std::memory_order_relaxed));
-  }
+  void Ref(Value n = 1) { value_.FetchAdd(n, MemoryOrder::RELAXED); }
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
     if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
@@ -106,8 +105,7 @@ class RefCount {
   // Similar to Ref() with an assert on the ref-count being non-zero.
   void RefNonZero() {
 #ifndef NDEBUG
-    const Value prior =
-        GPR_ATM_INC_ADD_THEN(value_.fetch_add(1, std::memory_order_relaxed));
+    const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
     assert(prior > 0);
 #else
     Ref();
@@ -127,8 +125,7 @@ class RefCount {
 
   // Decrements the ref-count and returns true if the ref-count reaches 0.
   bool Unref() {
-    const Value prior =
-        GPR_ATM_INC_ADD_THEN(value_.fetch_sub(1, std::memory_order_acq_rel));
+    const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
     GPR_DEBUG_ASSERT(prior > 0);
     return prior == 1;
   }
@@ -145,12 +142,12 @@ class RefCount {
   }
 
  private:
-  Value get() const { return value_.load(std::memory_order_relaxed); }
+  Value get() const { return value_.Load(MemoryOrder::RELAXED); }
 
 #ifndef NDEBUG
   TraceFlag* trace_flag_;
 #endif
-  std::atomic<Value> value_;
+  Atomic<Value> value_;
 };
 
 // A base class for reference-counted objects.
@@ -221,8 +218,9 @@ class RefCounted : public Impl {
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
   template <typename TraceFlagT = TraceFlag>
-  explicit RefCounted(TraceFlagT* trace_flag = nullptr)
-      : refs_(1, trace_flag) {}
+  explicit RefCounted(TraceFlagT* trace_flag = nullptr,
+                      intptr_t initial_refcount = 1)
+      : refs_(initial_refcount, trace_flag) {}
 
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~RefCounted() = default;

src/core/lib/gprpp/thd.h

@@ -109,7 +109,7 @@ class Thread {
     } else {
       GPR_ASSERT(state_ == FAILED);
     }
-  };
+  }
 
  private:
   Thread(const Thread&) = delete;

src/core/lib/iomgr/buffer_list.h

@@ -160,6 +160,6 @@ void grpc_tcp_set_write_timestamps_callback(void (*fn)(void*,
                                                        grpc_core::Timestamps*,
                                                        grpc_error* error));
 
-}; /* namespace grpc_core */
+} /* namespace grpc_core */
 
 #endif /* GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H */

src/core/lib/iomgr/endpoint_cfstream.cc

@@ -182,7 +182,7 @@ static void ReadAction(void* arg, grpc_error* error) {
                    GRPC_ERROR_CREATE_FROM_STATIC_STRING("Socket closed"), ep));
     EP_UNREF(ep, "read");
   } else {
-    if (read_size < len) {
+    if (read_size < static_cast<CFIndex>(len)) {
       grpc_slice_buffer_trim_end(ep->read_slices, len - read_size, nullptr);
     }
     CallReadCb(ep, GRPC_ERROR_NONE);
@@ -217,7 +217,7 @@ static void WriteAction(void* arg, grpc_error* error) {
     CallWriteCb(ep, error);
     EP_UNREF(ep, "write");
   } else {
-    if (write_size < GRPC_SLICE_LENGTH(slice)) {
+    if (write_size < static_cast<CFIndex>(GRPC_SLICE_LENGTH(slice))) {
       grpc_slice_buffer_undo_take_first(
           ep->write_slices, grpc_slice_sub(slice, write_size, slice_len));
     }

src/core/lib/surface/lame_client.cc

@@ -25,10 +25,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/atomic.h"
-
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
@@ -43,7 +42,7 @@ struct CallData {
   grpc_call_combiner* call_combiner;
   grpc_linked_mdelem status;
   grpc_linked_mdelem details;
-  grpc_core::atomic<bool> filled_metadata;
+  grpc_core::Atomic<bool> filled_metadata;
 };
 
 struct ChannelData {
@@ -54,9 +53,8 @@ struct ChannelData {
 static void fill_metadata(grpc_call_element* elem, grpc_metadata_batch* mdb) {
   CallData* calld = static_cast<CallData*>(elem->call_data);
   bool expected = false;
-  if (!calld->filled_metadata.compare_exchange_strong(
-          expected, true, grpc_core::memory_order_relaxed,
-          grpc_core::memory_order_relaxed)) {
+  if (!calld->filled_metadata.CompareExchangeStrong(
+          &expected, true, MemoryOrder::RELAXED, MemoryOrder::RELAXED)) {
     return;
   }
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);

src/core/lib/transport/service_config.cc

@@ -33,14 +33,14 @@
 
 namespace grpc_core {
 
-UniquePtr<ServiceConfig> ServiceConfig::Create(const char* json) {
+RefCountedPtr<ServiceConfig> ServiceConfig::Create(const char* json) {
   UniquePtr<char> json_string(gpr_strdup(json));
   grpc_json* json_tree = grpc_json_parse_string(json_string.get());
   if (json_tree == nullptr) {
     gpr_log(GPR_INFO, "failed to parse JSON for service config");
     return nullptr;
   }
-  return MakeUnique<ServiceConfig>(std::move(json_string), json_tree);
+  return MakeRefCounted<ServiceConfig>(std::move(json_string), json_tree);
 }
 
 ServiceConfig::ServiceConfig(UniquePtr<char> json_string, grpc_json* json_tree)

src/core/lib/transport/service_config.h

@@ -23,6 +23,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_hash_table.h"
@@ -41,8 +42,7 @@
 //         }
 //       ],
 //       // remaining fields are optional.
-//       // see
-//       https://developers.google.com/protocol-buffers/docs/proto3#json
+//       // see https://developers.google.com/protocol-buffers/docs/proto3#json
 //       // for format details.
 //       "waitForReady": bool,
 //       "timeout": "duration_string",
@@ -54,11 +54,11 @@
 
 namespace grpc_core {
 
-class ServiceConfig {
+class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static UniquePtr<ServiceConfig> Create(const char* json);
+  static RefCountedPtr<ServiceConfig> Create(const char* json);
 
   ~ServiceConfig();
 

src/cpp/common/core_codegen.cc

@@ -81,7 +81,7 @@ void CoreCodegen::gpr_free(void* p) { return ::gpr_free(p); }
 void CoreCodegen::grpc_init() { ::grpc_init(); }
 void CoreCodegen::grpc_shutdown() { ::grpc_shutdown(); }
 
-void CoreCodegen::gpr_mu_init(gpr_mu* mu) { ::gpr_mu_init(mu); };
+void CoreCodegen::gpr_mu_init(gpr_mu* mu) { ::gpr_mu_init(mu); }
 void CoreCodegen::gpr_mu_destroy(gpr_mu* mu) { ::gpr_mu_destroy(mu); }
 void CoreCodegen::gpr_mu_lock(gpr_mu* mu) { ::gpr_mu_lock(mu); }
 void CoreCodegen::gpr_mu_unlock(gpr_mu* mu) { ::gpr_mu_unlock(mu); }

src/cpp/server/load_reporter/get_cpu_stats_linux.cc

@@ -32,7 +32,10 @@ std::pair<uint64_t, uint64_t> GetCpuStatsImpl() {
   FILE* fp;
   fp = fopen("/proc/stat", "r");
   uint64_t user, nice, system, idle;
-  fscanf(fp, "cpu %lu %lu %lu %lu", &user, &nice, &system, &idle);
+  if (fscanf(fp, "cpu %lu %lu %lu %lu", &user, &nice, &system, &idle) != 4) {
+    // Something bad happened with the information, so assume it's all invalid
+    user = nice = system = idle = 0;
+  }
   fclose(fp);
   busy = user + nice + system;
   total = busy + idle;

src/cpp/server/server_cc.cc

@@ -1251,6 +1251,6 @@ CompletionQueue* Server::CallbackCQ() {
     shutdown_callback->TakeCQ(callback_cq_);
   }
   return callback_cq_;
-};
+}
 
 }  // namespace grpc

src/cpp/server/server_context.cc

@@ -138,7 +138,7 @@ class ServerContext::CompletionOp final : public internal::CallOpSetInterface {
   }
 
   internal::Call call_;
-  internal::ServerReactor* reactor_;
+  internal::ServerReactor* const reactor_;
   bool has_tag_;
   void* tag_;
   void* core_cq_tag_;
@@ -200,12 +200,17 @@ bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {
     cancelled_ = 1;
   }
 
-  if (cancelled_ && (reactor_ != nullptr)) {
+  // Decide whether to call the cancel callback before releasing the lock
+  bool call_cancel = (cancelled_ != 0);
+
+  // Release the lock since we are going to be calling a callback and
+  // interceptors now
+  lock.unlock();
+
+  if (call_cancel && (reactor_ != nullptr)) {
     reactor_->OnCancel();
   }
-  /* Release the lock since we are going to be running through interceptors now
-   */
-  lock.unlock();
+
   /* Add interception point and run through interceptors */
   interceptor_methods_.AddInterceptionHookPoint(
       experimental::InterceptionHookPoints::POST_RECV_CLOSE);

src/csharp/Grpc.Core.Api/ServerCallContext.cs

@@ -17,6 +17,7 @@
 #endregion
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -27,6 +28,8 @@ namespace Grpc.Core
     /// </summary>
     public abstract class ServerCallContext
     {
+        private Dictionary<object, object> userState;
+
         /// <summary>
         /// Creates a new instance of <c>ServerCallContext</c>.
         /// </summary>
@@ -113,6 +116,12 @@ namespace Grpc.Core
         /// </summary>
         public AuthContext AuthContext => AuthContextCore;
 
+        /// <summary>
+        /// Gets a dictionary that can be used by the various interceptors and handlers of this
+        /// call to store arbitrary state.
+        /// </summary>
+        public IDictionary<object, object> UserState => UserStateCore;
+
         /// <summary>Provides implementation of a non-virtual public member.</summary>
         protected abstract Task WriteResponseHeadersAsyncCore(Metadata responseHeaders);
         /// <summary>Provides implementation of a non-virtual public member.</summary>
@@ -135,7 +144,20 @@ namespace Grpc.Core
         protected abstract Status StatusCore { get; set; }
         /// <summary>Provides implementation of a non-virtual public member.</summary>
         protected abstract WriteOptions WriteOptionsCore { get; set; }
-          /// <summary>Provides implementation of a non-virtual public member.</summary>
+        /// <summary>Provides implementation of a non-virtual public member.</summary>
         protected abstract AuthContext AuthContextCore { get; }
+        /// <summary>Provides implementation of a non-virtual public member.</summary>
+        protected virtual IDictionary<object, object> UserStateCore
+        {
+            get
+            {
+                if (userState == null)
+                {
+                    userState = new Dictionary<object, object>();
+                }
+
+                return userState;
+            }
+        }
     }
 }

src/csharp/Grpc.Core.Tests/Interceptors/ServerInterceptorTest.cs

@@ -77,6 +77,53 @@ namespace Grpc.Core.Interceptors.Tests
             Assert.AreEqual("CB1B2B3A", stringBuilder.ToString());
         }
 
+        [Test]
+        public void UserStateVisibleToAllInterceptors()
+        {
+            object key1 = new object();
+            object value1 = new object();
+            const string key2 = "Interceptor #2";
+            const string value2 = "Important state";
+
+            var interceptor1 = new ServerCallContextInterceptor(ctx => {
+                // state starts off empty
+                Assert.AreEqual(0, ctx.UserState.Count);
+
+                ctx.UserState.Add(key1, value1);
+            });
+
+            var interceptor2 = new ServerCallContextInterceptor(ctx => {
+                // second interceptor can see state set by the first
+                bool found = ctx.UserState.TryGetValue(key1, out object storedValue1);
+                Assert.IsTrue(found);
+                Assert.AreEqual(value1, storedValue1);
+
+                ctx.UserState.Add(key2, value2);
+            });
+
+            var helper = new MockServiceHelper(Host);
+            helper.UnaryHandler = new UnaryServerMethod<string, string>((request, context) => {
+                // call handler can see all the state
+                bool found = context.UserState.TryGetValue(key1, out object storedValue1);
+                Assert.IsTrue(found);
+                Assert.AreEqual(value1, storedValue1);
+
+                found = context.UserState.TryGetValue(key2, out object storedValue2);
+                Assert.IsTrue(found);
+                Assert.AreEqual(value2, storedValue2);
+
+                return Task.FromResult("PASS");
+            });
+            helper.ServiceDefinition = helper.ServiceDefinition
+                .Intercept(interceptor2)
+                .Intercept(interceptor1);
+
+            var server = helper.GetServer();
+            server.Start();
+            var channel = helper.GetChannel();
+            Assert.AreEqual("PASS", Calls.BlockingUnaryCall(helper.CreateUnaryCall(), ""));
+        }
+
         [Test]
         public void CheckNullInterceptorRegistrationFails()
         {

src/python/grpcio/commands.py

@@ -212,50 +212,39 @@ class BuildExt(build_ext.build_ext):
     LINK_OPTIONS = {}
 
     def build_extensions(self):
+
+        def compiler_ok_with_extra_std():
+            """Test if default compiler is okay with specifying c++ version
+            when invoked in C mode. GCC is okay with this, while clang is not.
+            """
+            cc_test = subprocess.Popen(
+                ['cc', '-x', 'c', '-std=c++11', '-'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE)
+            _, cc_err = cc_test.communicate(input='int main(){return 0;}')
+            return not 'invalid argument' in str(cc_err)
+
         # This special conditioning is here due to difference of compiler
         #   behavior in gcc and clang. The clang doesn't take --stdc++11
         #   flags but gcc does. Since the setuptools of Python only support
         #   all C or all C++ compilation, the mix of C and C++ will crash.
-        #   *By default*, the macOS use clang and Linux use gcc, that's why
-        #   the special condition here is checking platform.
-        if "darwin" in sys.platform:
-            config = os.environ.get('CONFIG', 'opt')
-            target_path = os.path.abspath(
-                os.path.join(
-                    os.path.dirname(os.path.realpath(__file__)), '..', '..',
-                    '..', 'libs', config))
-            targets = [
-                os.path.join(target_path, 'libboringssl.a'),
-                os.path.join(target_path, 'libares.a'),
-                os.path.join(target_path, 'libgpr.a'),
-                os.path.join(target_path, 'libgrpc.a')
-            ]
-            # Running make separately for Mac means we lose all
-            # Extension.define_macros configured in setup.py. Re-add the macro
-            # for gRPC Core's fork handlers.
-            # TODO(ericgribkoff) Decide what to do about the other missing core
-            #   macros, including GRPC_ENABLE_FORK_SUPPORT, which defaults to 1
-            #   on Linux but remains unset on Mac.
-            extra_defines = [
-                'EXTRA_DEFINES="GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK=1"'
-            ]
-            # Ensure the BoringSSL are built instead of using system provided
-            #   libraries. It prevents dependency issues while distributing to
-            #   Mac users who use MacPorts to manage their libraries. #17002
-            mod_env = dict(os.environ)
-            mod_env['REQUIRE_CUSTOM_LIBRARIES_opt'] = '1'
-            make_process = subprocess.Popen(
-                ['make'] + extra_defines + targets,
-                env=mod_env,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE)
-            make_out, make_err = make_process.communicate()
-            if make_out and make_process.returncode != 0:
-                sys.stdout.write(str(make_out) + '\n')
-            if make_err:
-                sys.stderr.write(str(make_err) + '\n')
-            if make_process.returncode != 0:
-                raise Exception("make command failed!")
+        #   *By default*, macOS and FreBSD use clang and Linux use gcc
+        #
+        #   If we are not using a permissive compiler that's OK with being
+        #   passed wrong std flags, swap out compile function by adding a filter
+        #   for it.
+        if not compiler_ok_with_extra_std():
+            old_compile = self.compiler._compile
+
+            def new_compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
+                if src[-2:] == '.c':
+                    extra_postargs = [
+                        arg for arg in extra_postargs if not '-std=c++' in arg
+                    ]
+                return old_compile(obj, src, ext, cc_args, extra_postargs,
+                                   pp_opts)
+
+            self.compiler._compile = new_compile
 
         compiler = self.compiler.compiler_type
         if compiler in BuildExt.C_OPTIONS:

src/python/grpcio/grpc/_server.py

@@ -19,6 +19,7 @@ import logging
 import threading
 import time
 
+from concurrent import futures
 import six
 
 import grpc
@@ -111,7 +112,7 @@ def _raise_rpc_error(state):
 
 def _possibly_finish_call(state, token):
     state.due.remove(token)
-    if (state.client is _CANCELLED or state.statused) and not state.due:
+    if not _is_rpc_state_active(state) and not state.due:
         callbacks = state.callbacks
         state.callbacks = None
         return state, callbacks
@@ -218,7 +219,7 @@ class _Context(grpc.ServicerContext):
 
     def is_active(self):
         with self._state.condition:
-            return self._state.client is not _CANCELLED and not self._state.statused
+            return _is_rpc_state_active(self._state)
 
     def time_remaining(self):
         return max(self._rpc_event.call_details.deadline - time.time(), 0)
@@ -313,7 +314,7 @@ class _RequestIterator(object):
     def _raise_or_start_receive_message(self):
         if self._state.client is _CANCELLED:
             _raise_rpc_error(self._state)
-        elif self._state.client is _CLOSED or self._state.statused:
+        elif not _is_rpc_state_active(self._state):
             raise StopIteration()
         else:
             self._call.start_server_batch(
@@ -358,7 +359,7 @@ def _unary_request(rpc_event, state, request_deserializer):
 
     def unary_request():
         with state.condition:
-            if state.client is _CANCELLED or state.statused:
+            if not _is_rpc_state_active(state):
                 return None
             else:
                 rpc_event.call.start_server_batch(
@@ -386,21 +387,32 @@ def _unary_request(rpc_event, state, request_deserializer):
     return unary_request
 
 
-def _call_behavior(rpc_event, state, behavior, argument, request_deserializer):
-    context = _Context(rpc_event, state, request_deserializer)
-    try:
-        return behavior(argument, context), True
-    except Exception as exception:  # pylint: disable=broad-except
-        with state.condition:
-            if state.aborted:
-                _abort(state, rpc_event.call, cygrpc.StatusCode.unknown,
-                       b'RPC Aborted')
-            elif exception not in state.rpc_errors:
-                details = 'Exception calling application: {}'.format(exception)
-                _LOGGER.exception(details)
-                _abort(state, rpc_event.call, cygrpc.StatusCode.unknown,
-                       _common.encode(details))
-        return None, False
+def _call_behavior(rpc_event,
+                   state,
+                   behavior,
+                   argument,
+                   request_deserializer,
+                   send_response_callback=None):
+    from grpc import _create_servicer_context
+    with _create_servicer_context(rpc_event, state,
+                                  request_deserializer) as context:
+        try:
+            if send_response_callback is not None:
+                return behavior(argument, context, send_response_callback), True
+            else:
+                return behavior(argument, context), True
+        except Exception as exception:  # pylint: disable=broad-except
+            with state.condition:
+                if state.aborted:
+                    _abort(state, rpc_event.call, cygrpc.StatusCode.unknown,
+                           b'RPC Aborted')
+                elif exception not in state.rpc_errors:
+                    details = 'Exception calling application: {}'.format(
+                        exception)
+                    _LOGGER.exception(details)
+                    _abort(state, rpc_event.call, cygrpc.StatusCode.unknown,
+                           _common.encode(details))
+            return None, False
 
 
 def _take_response_from_response_iterator(rpc_event, state, response_iterator):
@@ -434,7 +446,7 @@ def _serialize_response(rpc_event, state, response, response_serializer):
 
 def _send_response(rpc_event, state, serialized_response):
     with state.condition:
-        if state.client is _CANCELLED or state.statused:
+        if not _is_rpc_state_active(state):
             return False
         else:
             if state.initial_metadata_allowed:
@@ -455,7 +467,7 @@ def _send_response(rpc_event, state, serialized_response):
             while True:
                 state.condition.wait()
                 if token not in state.due:
-                    return state.client is not _CANCELLED and not state.statused
+                    return _is_rpc_state_active(state)
 
 
 def _status(rpc_event, state, serialized_response):
@@ -501,65 +513,102 @@ def _unary_response_in_pool(rpc_event, state, behavior, argument_thunk,
 def _stream_response_in_pool(rpc_event, state, behavior, argument_thunk,
                              request_deserializer, response_serializer):
     cygrpc.install_context_from_request_call_event(rpc_event)
+
+    def send_response(response):
+        if response is None:
+            _status(rpc_event, state, None)
+        else:
+            serialized_response = _serialize_response(
+                rpc_event, state, response, response_serializer)
+            if serialized_response is not None:
+                _send_response(rpc_event, state, serialized_response)
+
     try:
         argument = argument_thunk()
         if argument is not None:
-            response_iterator, proceed = _call_behavior(
-                rpc_event, state, behavior, argument, request_deserializer)
-            if proceed:
-                while True:
-                    response, proceed = _take_response_from_response_iterator(
-                        rpc_event, state, response_iterator)
-                    if proceed:
-                        if response is None:
-                            _status(rpc_event, state, None)
-                            break
-                        else:
-                            serialized_response = _serialize_response(
-                                rpc_event, state, response, response_serializer)
-                            if serialized_response is not None:
-                                proceed = _send_response(
-                                    rpc_event, state, serialized_response)
-                                if not proceed:
-                                    break
-                            else:
-                                break
-                    else:
-                        break
+            if hasattr(behavior, 'experimental_non_blocking'
+                      ) and behavior.experimental_non_blocking:
+                _call_behavior(
+                    rpc_event,
+                    state,
+                    behavior,
+                    argument,
+                    request_deserializer,
+                    send_response_callback=send_response)
+            else:
+                response_iterator, proceed = _call_behavior(
+                    rpc_event, state, behavior, argument, request_deserializer)
+                if proceed:
+                    _send_message_callback_to_blocking_iterator_adapter(
+                        rpc_event, state, send_response, response_iterator)
     finally:
         cygrpc.uninstall_context()
 
 
-def _handle_unary_unary(rpc_event, state, method_handler, thread_pool):
+def _is_rpc_state_active(state):
+    return state.client is not _CANCELLED and not state.statused
+
+
+def _send_message_callback_to_blocking_iterator_adapter(
+        rpc_event, state, send_response_callback, response_iterator):
+    while True:
+        response, proceed = _take_response_from_response_iterator(
+            rpc_event, state, response_iterator)
+        if proceed:
+            send_response_callback(response)
+            if not _is_rpc_state_active(state):
+                break
+        else:
+            break
+
+
+def _select_thread_pool_for_behavior(behavior, default_thread_pool):
+    if hasattr(behavior, 'experimental_thread_pool') and isinstance(
+            behavior.experimental_thread_pool, futures.ThreadPoolExecutor):
+        return behavior.experimental_thread_pool
+    else:
+        return default_thread_pool
+
+
+def _handle_unary_unary(rpc_event, state, method_handler, default_thread_pool):
     unary_request = _unary_request(rpc_event, state,
                                    method_handler.request_deserializer)
+    thread_pool = _select_thread_pool_for_behavior(method_handler.unary_unary,
+                                                   default_thread_pool)
     return thread_pool.submit(_unary_response_in_pool, rpc_event, state,
                               method_handler.unary_unary, unary_request,
                               method_handler.request_deserializer,
                               method_handler.response_serializer)
 
 
-def _handle_unary_stream(rpc_event, state, method_handler, thread_pool):
+def _handle_unary_stream(rpc_event, state, method_handler, default_thread_pool):
     unary_request = _unary_request(rpc_event, state,
                                    method_handler.request_deserializer)
+    thread_pool = _select_thread_pool_for_behavior(method_handler.unary_stream,
+                                                   default_thread_pool)
     return thread_pool.submit(_stream_response_in_pool, rpc_event, state,
                               method_handler.unary_stream, unary_request,
                               method_handler.request_deserializer,
                               method_handler.response_serializer)
 
 
-def _handle_stream_unary(rpc_event, state, method_handler, thread_pool):
+def _handle_stream_unary(rpc_event, state, method_handler, default_thread_pool):
     request_iterator = _RequestIterator(state, rpc_event.call,
                                         method_handler.request_deserializer)
+    thread_pool = _select_thread_pool_for_behavior(method_handler.stream_unary,
+                                                   default_thread_pool)
     return thread_pool.submit(
         _unary_response_in_pool, rpc_event, state, method_handler.stream_unary,
         lambda: request_iterator, method_handler.request_deserializer,
         method_handler.response_serializer)
 
 
-def _handle_stream_stream(rpc_event, state, method_handler, thread_pool):
+def _handle_stream_stream(rpc_event, state, method_handler,
+                          default_thread_pool):
     request_iterator = _RequestIterator(state, rpc_event.call,
                                         method_handler.request_deserializer)
+    thread_pool = _select_thread_pool_for_behavior(method_handler.stream_stream,
+                                                   default_thread_pool)
     return thread_pool.submit(
         _stream_response_in_pool, rpc_event, state,
         method_handler.stream_stream, lambda: request_iterator,

src/python/grpcio/grpc_core_dependencies.py

@@ -329,10 +329,10 @@ CORE_SOURCE_FILES = [
     'src/core/ext/filters/client_channel/parse_address.cc',
     'src/core/ext/filters/client_channel/proxy_mapper.cc',
     'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
-    'src/core/ext/filters/client_channel/request_routing.cc',
     'src/core/ext/filters/client_channel/resolver.cc',
     'src/core/ext/filters/client_channel/resolver_registry.cc',
     'src/core/ext/filters/client_channel/resolver_result_parsing.cc',
+    'src/core/ext/filters/client_channel/resolving_lb_policy.cc',
     'src/core/ext/filters/client_channel/retry_throttle.cc',
     'src/core/ext/filters/client_channel/server_address.cc',
     'src/core/ext/filters/client_channel/subchannel.cc',

src/python/grpcio_health_checking/grpc_health/v1/health.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Reference implementation for health checking in gRPC Python."""
 
+import collections
 import threading
 
 import grpc
@@ -27,7 +28,7 @@ class _Watcher():
 
     def __init__(self):
         self._condition = threading.Condition()
-        self._responses = list()
+        self._responses = collections.deque()
         self._open = True
 
     def __iter__(self):
@@ -38,7 +39,7 @@ class _Watcher():
             while not self._responses and self._open:
                 self._condition.wait()
             if self._responses:
-                return self._responses.pop(0)
+                return self._responses.popleft()
             else:
                 raise StopIteration()
 
@@ -59,20 +60,37 @@ class _Watcher():
             self._condition.notify()
 
 
+def _watcher_to_send_response_callback_adapter(watcher):
+
+    def send_response_callback(response):
+        if response is None:
+            watcher.close()
+        else:
+            watcher.add(response)
+
+    return send_response_callback
+
+
 class HealthServicer(_health_pb2_grpc.HealthServicer):
     """Servicer handling RPCs for service statuses."""
 
-    def __init__(self):
+    def __init__(self,
+                 experimental_non_blocking=True,
+                 experimental_thread_pool=None):
         self._lock = threading.RLock()
         self._server_status = {}
-        self._watchers = {}
+        self._send_response_callbacks = {}
+        self.Watch.__func__.experimental_non_blocking = experimental_non_blocking
+        self.Watch.__func__.experimental_thread_pool = experimental_thread_pool
+        self._gracefully_shutting_down = False
 
-    def _on_close_callback(self, watcher, service):
+    def _on_close_callback(self, send_response_callback, service):
 
         def callback():
             with self._lock:
-                self._watchers[service].remove(watcher)
-            watcher.close()
+                self._send_response_callbacks[service].remove(
+                    send_response_callback)
+            send_response_callback(None)
 
         return callback
 
@@ -85,19 +103,29 @@ class HealthServicer(_health_pb2_grpc.HealthServicer):
             else:
                 return _health_pb2.HealthCheckResponse(status=status)
 
-    def Watch(self, request, context):
+    # pylint: disable=arguments-differ
+    def Watch(self, request, context, send_response_callback=None):
+        blocking_watcher = None
+        if send_response_callback is None:
+            # The server does not support the experimental_non_blocking
+            # parameter. For backwards compatibility, return a blocking response
+            # generator.
+            blocking_watcher = _Watcher()
+            send_response_callback = _watcher_to_send_response_callback_adapter(
+                blocking_watcher)
         service = request.service
         with self._lock:
             status = self._server_status.get(service)
             if status is None:
                 status = _health_pb2.HealthCheckResponse.SERVICE_UNKNOWN  # pylint: disable=no-member
-            watcher = _Watcher()
-            watcher.add(_health_pb2.HealthCheckResponse(status=status))
-            if service not in self._watchers:
-                self._watchers[service] = set()
-            self._watchers[service].add(watcher)
-            context.add_callback(self._on_close_callback(watcher, service))
-        return watcher
+            send_response_callback(
+                _health_pb2.HealthCheckResponse(status=status))
+            if service not in self._send_response_callbacks:
+                self._send_response_callbacks[service] = set()
+            self._send_response_callbacks[service].add(send_response_callback)
+            context.add_callback(
+                self._on_close_callback(send_response_callback, service))
+        return blocking_watcher
 
     def set(self, service, status):
         """Sets the status of a service.
@@ -108,7 +136,30 @@ class HealthServicer(_health_pb2_grpc.HealthServicer):
             the service
         """
         with self._lock:
-            self._server_status[service] = status
-            if service in self._watchers:
-                for watcher in self._watchers[service]:
-                    watcher.add(_health_pb2.HealthCheckResponse(status=status))
+            if self._gracefully_shutting_down:
+                return
+            else:
+                self._server_status[service] = status
+                if service in self._send_response_callbacks:
+                    for send_response_callback in self._send_response_callbacks[
+                            service]:
+                        send_response_callback(
+                            _health_pb2.HealthCheckResponse(status=status))
+
+    def enter_graceful_shutdown(self):
+        """Permanently sets the status of all services to NOT_SERVING.
+
+        This should be invoked when the server is entering a graceful shutdown
+        period. After this method is invoked, future attempts to set the status
+        of a service will be ignored.
+
+        This is an EXPERIMENTAL API.
+        """
+        with self._lock:
+            if self._gracefully_shutting_down:
+                return
+            else:
+                for service in self._server_status:
+                    self.set(service,
+                             _health_pb2.HealthCheckResponse.NOT_SERVING)  # pylint: disable=no-member
+                self._gracefully_shutting_down = True

src/python/grpcio_tests/tests/health_check/BUILD.bazel

@@ -9,6 +9,7 @@ py_test(
         "//src/python/grpcio/grpc:grpcio",
         "//src/python/grpcio_health_checking/grpc_health/v1:grpc_health",
         "//src/python/grpcio_tests/tests/unit:test_common",
+        "//src/python/grpcio_tests/tests/unit:thread_pool",
         "//src/python/grpcio_tests/tests/unit/framework/common:common",
     ],
     imports = ["../../",],

src/python/grpcio_tests/tests/health_check/_health_servicer_test.py

@@ -23,6 +23,7 @@ from grpc_health.v1 import health_pb2
 from grpc_health.v1 import health_pb2_grpc
 
 from tests.unit import test_common
+from tests.unit import thread_pool
 from tests.unit.framework.common import test_constants
 
 from six.moves import queue
@@ -38,29 +39,202 @@ def _consume_responses(response_iterator, response_queue):
         response_queue.put(response)
 
 
-class HealthServicerTest(unittest.TestCase):
+class BaseWatchTests(object):
+
+    class WatchTests(unittest.TestCase):
+
+        def start_server(self, non_blocking=False, thread_pool=None):
+            self._thread_pool = thread_pool
+            self._servicer = health.HealthServicer(
+                experimental_non_blocking=non_blocking,
+                experimental_thread_pool=thread_pool)
+            self._servicer.set('', health_pb2.HealthCheckResponse.SERVING)
+            self._servicer.set(_SERVING_SERVICE,
+                               health_pb2.HealthCheckResponse.SERVING)
+            self._servicer.set(_UNKNOWN_SERVICE,
+                               health_pb2.HealthCheckResponse.UNKNOWN)
+            self._servicer.set(_NOT_SERVING_SERVICE,
+                               health_pb2.HealthCheckResponse.NOT_SERVING)
+            self._server = test_common.test_server()
+            port = self._server.add_insecure_port('[::]:0')
+            health_pb2_grpc.add_HealthServicer_to_server(
+                self._servicer, self._server)
+            self._server.start()
+
+            self._channel = grpc.insecure_channel('localhost:%d' % port)
+            self._stub = health_pb2_grpc.HealthStub(self._channel)
+
+        def tearDown(self):
+            self._server.stop(None)
+            self._channel.close()
+
+        def test_watch_empty_service(self):
+            request = health_pb2.HealthCheckRequest(service='')
+            response_queue = queue.Queue()
+            rendezvous = self._stub.Watch(request)
+            thread = threading.Thread(
+                target=_consume_responses, args=(rendezvous, response_queue))
+            thread.start()
+
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
+                             response.status)
+
+            rendezvous.cancel()
+            thread.join()
+            self.assertTrue(response_queue.empty())
+
+            if self._thread_pool is not None:
+                self.assertTrue(self._thread_pool.was_used())
+
+        def test_watch_new_service(self):
+            request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
+            response_queue = queue.Queue()
+            rendezvous = self._stub.Watch(request)
+            thread = threading.Thread(
+                target=_consume_responses, args=(rendezvous, response_queue))
+            thread.start()
+
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
+                             response.status)
+
+            self._servicer.set(_WATCH_SERVICE,
+                               health_pb2.HealthCheckResponse.SERVING)
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
+                             response.status)
+
+            self._servicer.set(_WATCH_SERVICE,
+                               health_pb2.HealthCheckResponse.NOT_SERVING)
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.NOT_SERVING,
+                             response.status)
+
+            rendezvous.cancel()
+            thread.join()
+            self.assertTrue(response_queue.empty())
+
+        def test_watch_service_isolation(self):
+            request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
+            response_queue = queue.Queue()
+            rendezvous = self._stub.Watch(request)
+            thread = threading.Thread(
+                target=_consume_responses, args=(rendezvous, response_queue))
+            thread.start()
+
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
+                             response.status)
+
+            self._servicer.set('some-other-service',
+                               health_pb2.HealthCheckResponse.SERVING)
+            with self.assertRaises(queue.Empty):
+                response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+
+            rendezvous.cancel()
+            thread.join()
+            self.assertTrue(response_queue.empty())
+
+        def test_two_watchers(self):
+            request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
+            response_queue1 = queue.Queue()
+            response_queue2 = queue.Queue()
+            rendezvous1 = self._stub.Watch(request)
+            rendezvous2 = self._stub.Watch(request)
+            thread1 = threading.Thread(
+                target=_consume_responses, args=(rendezvous1, response_queue1))
+            thread2 = threading.Thread(
+                target=_consume_responses, args=(rendezvous2, response_queue2))
+            thread1.start()
+            thread2.start()
+
+            response1 = response_queue1.get(
+                timeout=test_constants.SHORT_TIMEOUT)
+            response2 = response_queue2.get(
+                timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
+                             response1.status)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
+                             response2.status)
+
+            self._servicer.set(_WATCH_SERVICE,
+                               health_pb2.HealthCheckResponse.SERVING)
+            response1 = response_queue1.get(
+                timeout=test_constants.SHORT_TIMEOUT)
+            response2 = response_queue2.get(
+                timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
+                             response1.status)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
+                             response2.status)
+
+            rendezvous1.cancel()
+            rendezvous2.cancel()
+            thread1.join()
+            thread2.join()
+            self.assertTrue(response_queue1.empty())
+            self.assertTrue(response_queue2.empty())
+
+        @unittest.skip("https://github.com/grpc/grpc/issues/18127")
+        def test_cancelled_watch_removed_from_watch_list(self):
+            request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
+            response_queue = queue.Queue()
+            rendezvous = self._stub.Watch(request)
+            thread = threading.Thread(
+                target=_consume_responses, args=(rendezvous, response_queue))
+            thread.start()
+
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
+                             response.status)
+
+            rendezvous.cancel()
+            self._servicer.set(_WATCH_SERVICE,
+                               health_pb2.HealthCheckResponse.SERVING)
+            thread.join()
+
+            # Wait, if necessary, for serving thread to process client cancellation
+            timeout = time.time() + test_constants.TIME_ALLOWANCE
+            while time.time(
+            ) < timeout and self._servicer._send_response_callbacks[_WATCH_SERVICE]:
+                time.sleep(1)
+            self.assertFalse(
+                self._servicer._send_response_callbacks[_WATCH_SERVICE],
+                'watch set should be empty')
+            self.assertTrue(response_queue.empty())
+
+        def test_graceful_shutdown(self):
+            request = health_pb2.HealthCheckRequest(service='')
+            response_queue = queue.Queue()
+            rendezvous = self._stub.Watch(request)
+            thread = threading.Thread(
+                target=_consume_responses, args=(rendezvous, response_queue))
+            thread.start()
+
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
+                             response.status)
+
+            self._servicer.enter_graceful_shutdown()
+            response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
+            self.assertEqual(health_pb2.HealthCheckResponse.NOT_SERVING,
+                             response.status)
+
+            # This should be a no-op.
+            self._servicer.set('', health_pb2.HealthCheckResponse.SERVING)
+
+            rendezvous.cancel()
+            thread.join()
+            self.assertTrue(response_queue.empty())
+
+
+class HealthServicerTest(BaseWatchTests.WatchTests):
 
     def setUp(self):
-        self._servicer = health.HealthServicer()
-        self._servicer.set('', health_pb2.HealthCheckResponse.SERVING)
-        self._servicer.set(_SERVING_SERVICE,
-                           health_pb2.HealthCheckResponse.SERVING)
-        self._servicer.set(_UNKNOWN_SERVICE,
-                           health_pb2.HealthCheckResponse.UNKNOWN)
-        self._servicer.set(_NOT_SERVING_SERVICE,
-                           health_pb2.HealthCheckResponse.NOT_SERVING)
-        self._server = test_common.test_server()
-        port = self._server.add_insecure_port('[::]:0')
-        health_pb2_grpc.add_HealthServicer_to_server(self._servicer,
-                                                     self._server)
-        self._server.start()
-
-        self._channel = grpc.insecure_channel('localhost:%d' % port)
-        self._stub = health_pb2_grpc.HealthStub(self._channel)
-
-    def tearDown(self):
-        self._server.stop(None)
-        self._channel.close()
+        self._thread_pool = thread_pool.RecordingThreadPool(max_workers=None)
+        super(HealthServicerTest, self).start_server(
+            non_blocking=True, thread_pool=self._thread_pool)
 
     def test_check_empty_service(self):
         request = health_pb2.HealthCheckRequest()
@@ -90,135 +264,16 @@ class HealthServicerTest(unittest.TestCase):
 
         self.assertEqual(grpc.StatusCode.NOT_FOUND, context.exception.code())
 
-    def test_watch_empty_service(self):
-        request = health_pb2.HealthCheckRequest(service='')
-        response_queue = queue.Queue()
-        rendezvous = self._stub.Watch(request)
-        thread = threading.Thread(
-            target=_consume_responses, args=(rendezvous, response_queue))
-        thread.start()
-
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
-                         response.status)
-
-        rendezvous.cancel()
-        thread.join()
-        self.assertTrue(response_queue.empty())
-
-    def test_watch_new_service(self):
-        request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
-        response_queue = queue.Queue()
-        rendezvous = self._stub.Watch(request)
-        thread = threading.Thread(
-            target=_consume_responses, args=(rendezvous, response_queue))
-        thread.start()
-
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
-                         response.status)
-
-        self._servicer.set(_WATCH_SERVICE,
-                           health_pb2.HealthCheckResponse.SERVING)
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
-                         response.status)
-
-        self._servicer.set(_WATCH_SERVICE,
-                           health_pb2.HealthCheckResponse.NOT_SERVING)
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.NOT_SERVING,
-                         response.status)
-
-        rendezvous.cancel()
-        thread.join()
-        self.assertTrue(response_queue.empty())
-
-    def test_watch_service_isolation(self):
-        request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
-        response_queue = queue.Queue()
-        rendezvous = self._stub.Watch(request)
-        thread = threading.Thread(
-            target=_consume_responses, args=(rendezvous, response_queue))
-        thread.start()
-
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
-                         response.status)
-
-        self._servicer.set('some-other-service',
-                           health_pb2.HealthCheckResponse.SERVING)
-        with self.assertRaises(queue.Empty):
-            response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-
-        rendezvous.cancel()
-        thread.join()
-        self.assertTrue(response_queue.empty())
-
-    def test_two_watchers(self):
-        request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
-        response_queue1 = queue.Queue()
-        response_queue2 = queue.Queue()
-        rendezvous1 = self._stub.Watch(request)
-        rendezvous2 = self._stub.Watch(request)
-        thread1 = threading.Thread(
-            target=_consume_responses, args=(rendezvous1, response_queue1))
-        thread2 = threading.Thread(
-            target=_consume_responses, args=(rendezvous2, response_queue2))
-        thread1.start()
-        thread2.start()
-
-        response1 = response_queue1.get(timeout=test_constants.SHORT_TIMEOUT)
-        response2 = response_queue2.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
-                         response1.status)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
-                         response2.status)
-
-        self._servicer.set(_WATCH_SERVICE,
-                           health_pb2.HealthCheckResponse.SERVING)
-        response1 = response_queue1.get(timeout=test_constants.SHORT_TIMEOUT)
-        response2 = response_queue2.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
-                         response1.status)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVING,
-                         response2.status)
-
-        rendezvous1.cancel()
-        rendezvous2.cancel()
-        thread1.join()
-        thread2.join()
-        self.assertTrue(response_queue1.empty())
-        self.assertTrue(response_queue2.empty())
-
-    def test_cancelled_watch_removed_from_watch_list(self):
-        request = health_pb2.HealthCheckRequest(service=_WATCH_SERVICE)
-        response_queue = queue.Queue()
-        rendezvous = self._stub.Watch(request)
-        thread = threading.Thread(
-            target=_consume_responses, args=(rendezvous, response_queue))
-        thread.start()
-
-        response = response_queue.get(timeout=test_constants.SHORT_TIMEOUT)
-        self.assertEqual(health_pb2.HealthCheckResponse.SERVICE_UNKNOWN,
-                         response.status)
-
-        rendezvous.cancel()
-        self._servicer.set(_WATCH_SERVICE,
-                           health_pb2.HealthCheckResponse.SERVING)
-        thread.join()
-
-        # Wait, if necessary, for serving thread to process client cancellation
-        timeout = time.time() + test_constants.SHORT_TIMEOUT
-        while time.time() < timeout and self._servicer._watchers[_WATCH_SERVICE]:
-            time.sleep(1)
-        self.assertFalse(self._servicer._watchers[_WATCH_SERVICE],
-                         'watch set should be empty')
-        self.assertTrue(response_queue.empty())
-
     def test_health_service_name(self):
         self.assertEqual(health.SERVICE_NAME, 'grpc.health.v1.Health')
 
 
+class HealthServicerBackwardsCompatibleWatchTest(BaseWatchTests.WatchTests):
+
+    def setUp(self):
+        super(HealthServicerBackwardsCompatibleWatchTest, self).start_server(
+            non_blocking=False, thread_pool=None)
+
+
 if __name__ == '__main__':
     unittest.main(verbosity=2)

src/python/grpcio_tests/tests/tests.json

@@ -2,6 +2,7 @@
   "_sanity._sanity_test.SanityTest",
   "channelz._channelz_servicer_test.ChannelzServicerTest",
   "fork._fork_interop_test.ForkInteropTest",
+  "health_check._health_servicer_test.HealthServicerBackwardsCompatibleWatchTest",
   "health_check._health_servicer_test.HealthServicerTest",
   "interop._insecure_intraop_test.InsecureIntraopTest",
   "interop._secure_intraop_test.SecureIntraopTest",

src/python/grpcio_tests/tests/unit/BUILD.bazel

@@ -46,6 +46,11 @@ py_library(
     srcs = ["test_common.py"],
 )
 
+py_library(
+    name = "thread_pool",
+    srcs = ["thread_pool.py"],
+)
+
 py_library(
     name = "_exit_scenarios",
     srcs = ["_exit_scenarios.py"],
@@ -56,11 +61,6 @@ py_library(
     srcs = ["_server_shutdown_scenarios.py"],
 )
 
-py_library(
-    name = "_thread_pool",
-    srcs = ["_thread_pool.py"],
-)
-
 py_library(
     name = "_from_grpc_import_star",
     srcs = ["_from_grpc_import_star.py"],
@@ -76,9 +76,9 @@ py_library(
             "//src/python/grpcio/grpc:grpcio",
             ":resources",
             ":test_common",
+            ":thread_pool",
             ":_exit_scenarios",
             ":_server_shutdown_scenarios",
-            ":_thread_pool",
             ":_from_grpc_import_star",
             "//src/python/grpcio_tests/tests/unit/framework/common",
             "//src/python/grpcio_tests/tests/testing",

src/python/grpcio_tests/tests/unit/_abort_test.py

@@ -115,6 +115,7 @@ class AbortTest(unittest.TestCase):
     # on Python 3 (via the `__traceback__` attribute) holds a reference to
     # all local vars. Storing the raised exception can prevent GC and stop the
     # grpc_call from being unref'ed, even after server shutdown.
+    @unittest.skip("https://github.com/grpc/grpc/issues/17927")
     def test_abort_does_not_leak_local_vars(self):
         global do_not_leak_me  # pylint: disable=global-statement
         weak_ref = weakref.ref(do_not_leak_me)

src/python/grpcio_tests/tests/unit/_channel_connectivity_test.py

@@ -20,7 +20,7 @@ import unittest
 
 import grpc
 from tests.unit.framework.common import test_constants
-from tests.unit import _thread_pool
+from tests.unit import thread_pool
 
 
 def _ready_in_connectivities(connectivities):
@@ -85,8 +85,10 @@ class ChannelConnectivityTest(unittest.TestCase):
         self.assertNotIn(grpc.ChannelConnectivity.READY, fifth_connectivities)
 
     def test_immediately_connectable_channel_connectivity(self):
-        thread_pool = _thread_pool.RecordingThreadPool(max_workers=None)
-        server = grpc.server(thread_pool, options=(('grpc.so_reuseport', 0),))
+        recording_thread_pool = thread_pool.RecordingThreadPool(
+            max_workers=None)
+        server = grpc.server(
+            recording_thread_pool, options=(('grpc.so_reuseport', 0),))
         port = server.add_insecure_port('[::]:0')
         server.start()
         first_callback = _Callback()
@@ -125,11 +127,13 @@ class ChannelConnectivityTest(unittest.TestCase):
                          fourth_connectivities)
         self.assertNotIn(grpc.ChannelConnectivity.SHUTDOWN,
                          fourth_connectivities)
-        self.assertFalse(thread_pool.was_used())
+        self.assertFalse(recording_thread_pool.was_used())
 
     def test_reachable_then_unreachable_channel_connectivity(self):
-        thread_pool = _thread_pool.RecordingThreadPool(max_workers=None)
-        server = grpc.server(thread_pool, options=(('grpc.so_reuseport', 0),))
+        recording_thread_pool = thread_pool.RecordingThreadPool(
+            max_workers=None)
+        server = grpc.server(
+            recording_thread_pool, options=(('grpc.so_reuseport', 0),))
         port = server.add_insecure_port('[::]:0')
         server.start()
         callback = _Callback()
@@ -143,7 +147,7 @@ class ChannelConnectivityTest(unittest.TestCase):
             _last_connectivity_is_not_ready)
         channel.unsubscribe(callback.update)
         channel.close()
-        self.assertFalse(thread_pool.was_used())
+        self.assertFalse(recording_thread_pool.was_used())
 
 
 if __name__ == '__main__':

src/python/grpcio_tests/tests/unit/_channel_ready_future_test.py

@@ -19,7 +19,7 @@ import logging
 
 import grpc
 from tests.unit.framework.common import test_constants
-from tests.unit import _thread_pool
+from tests.unit import thread_pool
 
 
 class _Callback(object):
@@ -63,8 +63,10 @@ class ChannelReadyFutureTest(unittest.TestCase):
         channel.close()
 
     def test_immediately_connectable_channel_connectivity(self):
-        thread_pool = _thread_pool.RecordingThreadPool(max_workers=None)
-        server = grpc.server(thread_pool, options=(('grpc.so_reuseport', 0),))
+        recording_thread_pool = thread_pool.RecordingThreadPool(
+            max_workers=None)
+        server = grpc.server(
+            recording_thread_pool, options=(('grpc.so_reuseport', 0),))
         port = server.add_insecure_port('[::]:0')
         server.start()
         channel = grpc.insecure_channel('localhost:{}'.format(port))
@@ -84,7 +86,7 @@ class ChannelReadyFutureTest(unittest.TestCase):
         self.assertFalse(ready_future.cancelled())
         self.assertTrue(ready_future.done())
         self.assertFalse(ready_future.running())
-        self.assertFalse(thread_pool.was_used())
+        self.assertFalse(recording_thread_pool.was_used())
 
         channel.close()
         server.stop(None)

src/python/grpcio_tests/tests/unit/_rpc_test.py

@@ -23,6 +23,7 @@ import grpc
 from grpc.framework.foundation import logging_pool
 
 from tests.unit import test_common
+from tests.unit import thread_pool
 from tests.unit.framework.common import test_constants
 from tests.unit.framework.common import test_control
 
@@ -33,8 +34,10 @@ _DESERIALIZE_RESPONSE = lambda bytestring: bytestring[:len(bytestring) // 3]
 
 _UNARY_UNARY = '/test/UnaryUnary'
 _UNARY_STREAM = '/test/UnaryStream'
+_UNARY_STREAM_NON_BLOCKING = '/test/UnaryStreamNonBlocking'
 _STREAM_UNARY = '/test/StreamUnary'
 _STREAM_STREAM = '/test/StreamStream'
+_STREAM_STREAM_NON_BLOCKING = '/test/StreamStreamNonBlocking'
 
 
 class _Callback(object):
@@ -59,8 +62,14 @@ class _Callback(object):
 
 class _Handler(object):
 
-    def __init__(self, control):
+    def __init__(self, control, thread_pool):
         self._control = control
+        self._thread_pool = thread_pool
+        non_blocking_functions = (self.handle_unary_stream_non_blocking,
+                                  self.handle_stream_stream_non_blocking)
+        for non_blocking_function in non_blocking_functions:
+            non_blocking_function.__func__.experimental_non_blocking = True
+            non_blocking_function.__func__.experimental_thread_pool = self._thread_pool
 
     def handle_unary_unary(self, request, servicer_context):
         self._control.control()
@@ -87,6 +96,19 @@ class _Handler(object):
                 'testvalue',
             ),))
 
+    def handle_unary_stream_non_blocking(self, request, servicer_context,
+                                         on_next):
+        for _ in range(test_constants.STREAM_LENGTH):
+            self._control.control()
+            on_next(request)
+        self._control.control()
+        if servicer_context is not None:
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
+        on_next(None)
+
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
             servicer_context.invocation_metadata()
@@ -115,6 +137,20 @@ class _Handler(object):
             yield request
         self._control.control()
 
+    def handle_stream_stream_non_blocking(self, request_iterator,
+                                          servicer_context, on_next):
+        self._control.control()
+        if servicer_context is not None:
+            servicer_context.set_trailing_metadata(((
+                'testkey',
+                'testvalue',
+            ),))
+        for request in request_iterator:
+            self._control.control()
+            on_next(request)
+        self._control.control()
+        on_next(None)
+
 
 class _MethodHandler(grpc.RpcMethodHandler):
 
@@ -145,6 +181,10 @@ class _GenericHandler(grpc.GenericRpcHandler):
             return _MethodHandler(False, True, _DESERIALIZE_REQUEST,
                                   _SERIALIZE_RESPONSE, None,
                                   self._handler.handle_unary_stream, None, None)
+        elif handler_call_details.method == _UNARY_STREAM_NON_BLOCKING:
+            return _MethodHandler(
+                False, True, _DESERIALIZE_REQUEST, _SERIALIZE_RESPONSE, None,
+                self._handler.handle_unary_stream_non_blocking, None, None)
         elif handler_call_details.method == _STREAM_UNARY:
             return _MethodHandler(True, False, _DESERIALIZE_REQUEST,
                                   _SERIALIZE_RESPONSE, None, None,
@@ -152,6 +192,10 @@ class _GenericHandler(grpc.GenericRpcHandler):
         elif handler_call_details.method == _STREAM_STREAM:
             return _MethodHandler(True, True, None, None, None, None, None,
                                   self._handler.handle_stream_stream)
+        elif handler_call_details.method == _STREAM_STREAM_NON_BLOCKING:
+            return _MethodHandler(
+                True, True, None, None, None, None, None,
+                self._handler.handle_stream_stream_non_blocking)
         else:
             return None
 
@@ -167,6 +211,13 @@ def _unary_stream_multi_callable(channel):
         response_deserializer=_DESERIALIZE_RESPONSE)
 
 
+def _unary_stream_non_blocking_multi_callable(channel):
+    return channel.unary_stream(
+        _UNARY_STREAM_NON_BLOCKING,
+        request_serializer=_SERIALIZE_REQUEST,
+        response_deserializer=_DESERIALIZE_RESPONSE)
+
+
 def _stream_unary_multi_callable(channel):
     return channel.stream_unary(
         _STREAM_UNARY,
@@ -178,11 +229,16 @@ def _stream_stream_multi_callable(channel):
     return channel.stream_stream(_STREAM_STREAM)
 
 
+def _stream_stream_non_blocking_multi_callable(channel):
+    return channel.stream_stream(_STREAM_STREAM_NON_BLOCKING)
+
+
 class RPCTest(unittest.TestCase):
 
     def setUp(self):
         self._control = test_control.PauseFailControl()
-        self._handler = _Handler(self._control)
+        self._thread_pool = thread_pool.RecordingThreadPool(max_workers=None)
+        self._handler = _Handler(self._control, self._thread_pool)
 
         self._server = test_common.test_server()
         port = self._server.add_insecure_port('[::]:0')
@@ -195,6 +251,16 @@ class RPCTest(unittest.TestCase):
         self._server.stop(None)
         self._channel.close()
 
+    def testDefaultThreadPoolIsUsed(self):
+        self._consume_one_stream_response_unary_request(
+            _unary_stream_multi_callable(self._channel))
+        self.assertFalse(self._thread_pool.was_used())
+
+    def testExperimentalThreadPoolIsUsed(self):
+        self._consume_one_stream_response_unary_request(
+            _unary_stream_non_blocking_multi_callable(self._channel))
+        self.assertTrue(self._thread_pool.was_used())
+
     def testUnrecognizedMethod(self):
         request = b'abc'
 
@@ -227,7 +293,7 @@ class RPCTest(unittest.TestCase):
 
         self.assertEqual(expected_response, response)
         self.assertIs(grpc.StatusCode.OK, call.code())
-        self.assertEqual("", call.debug_error_string())
+        self.assertEqual('', call.debug_error_string())
 
     def testSuccessfulUnaryRequestFutureUnaryResponse(self):
         request = b'\x07\x08'
@@ -310,6 +376,7 @@ class RPCTest(unittest.TestCase):
     def testSuccessfulStreamRequestStreamResponse(self):
         requests = tuple(
             b'\x77\x58' for _ in range(test_constants.STREAM_LENGTH))
+
         expected_responses = tuple(
             self._handler.handle_stream_stream(iter(requests), None))
         request_iterator = iter(requests)
@@ -425,58 +492,36 @@ class RPCTest(unittest.TestCase):
             test_is_running_cell[0] = False
 
     def testConsumingOneStreamResponseUnaryRequest(self):
-        request = b'\x57\x38'
+        self._consume_one_stream_response_unary_request(
+            _unary_stream_multi_callable(self._channel))
 
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        response_iterator = multi_callable(
-            request,
-            metadata=(('test', 'ConsumingOneStreamResponseUnaryRequest'),))
-        next(response_iterator)
+    def testConsumingOneStreamResponseUnaryRequestNonBlocking(self):
+        self._consume_one_stream_response_unary_request(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testConsumingSomeButNotAllStreamResponsesUnaryRequest(self):
-        request = b'\x57\x38'
+        self._consume_some_but_not_all_stream_responses_unary_request(
+            _unary_stream_multi_callable(self._channel))
 
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        response_iterator = multi_callable(
-            request,
-            metadata=(('test',
-                       'ConsumingSomeButNotAllStreamResponsesUnaryRequest'),))
-        for _ in range(test_constants.STREAM_LENGTH // 2):
-            next(response_iterator)
+    def testConsumingSomeButNotAllStreamResponsesUnaryRequestNonBlocking(self):
+        self._consume_some_but_not_all_stream_responses_unary_request(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testConsumingSomeButNotAllStreamResponsesStreamRequest(self):
-        requests = tuple(
-            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
-        request_iterator = iter(requests)
+        self._consume_some_but_not_all_stream_responses_stream_request(
+            _stream_stream_multi_callable(self._channel))
 
-        multi_callable = _stream_stream_multi_callable(self._channel)
-        response_iterator = multi_callable(
-            request_iterator,
-            metadata=(('test',
-                       'ConsumingSomeButNotAllStreamResponsesStreamRequest'),))
-        for _ in range(test_constants.STREAM_LENGTH // 2):
-            next(response_iterator)
+    def testConsumingSomeButNotAllStreamResponsesStreamRequestNonBlocking(self):
+        self._consume_some_but_not_all_stream_responses_stream_request(
+            _stream_stream_non_blocking_multi_callable(self._channel))
 
     def testConsumingTooManyStreamResponsesStreamRequest(self):
-        requests = tuple(
-            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
-        request_iterator = iter(requests)
+        self._consume_too_many_stream_responses_stream_request(
+            _stream_stream_multi_callable(self._channel))
 
-        multi_callable = _stream_stream_multi_callable(self._channel)
-        response_iterator = multi_callable(
-            request_iterator,
-            metadata=(('test',
-                       'ConsumingTooManyStreamResponsesStreamRequest'),))
-        for _ in range(test_constants.STREAM_LENGTH):
-            next(response_iterator)
-        for _ in range(test_constants.STREAM_LENGTH):
-            with self.assertRaises(StopIteration):
-                next(response_iterator)
-
-        self.assertIsNotNone(response_iterator.initial_metadata())
-        self.assertIs(grpc.StatusCode.OK, response_iterator.code())
-        self.assertIsNotNone(response_iterator.details())
-        self.assertIsNotNone(response_iterator.trailing_metadata())
+    def testConsumingTooManyStreamResponsesStreamRequestNonBlocking(self):
+        self._consume_too_many_stream_responses_stream_request(
+            _stream_stream_non_blocking_multi_callable(self._channel))
 
     def testCancelledUnaryRequestUnaryResponse(self):
         request = b'\x07\x17'
@@ -498,24 +543,12 @@ class RPCTest(unittest.TestCase):
         self.assertIs(grpc.StatusCode.CANCELLED, response_future.code())
 
     def testCancelledUnaryRequestStreamResponse(self):
-        request = b'\x07\x19'
-
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        with self._control.pause():
-            response_iterator = multi_callable(
-                request,
-                metadata=(('test', 'CancelledUnaryRequestStreamResponse'),))
-            self._control.block_until_paused()
-            response_iterator.cancel()
+        self._cancelled_unary_request_stream_response(
+            _unary_stream_multi_callable(self._channel))
 
-        with self.assertRaises(grpc.RpcError) as exception_context:
-            next(response_iterator)
-        self.assertIs(grpc.StatusCode.CANCELLED,
-                      exception_context.exception.code())
-        self.assertIsNotNone(response_iterator.initial_metadata())
-        self.assertIs(grpc.StatusCode.CANCELLED, response_iterator.code())
-        self.assertIsNotNone(response_iterator.details())
-        self.assertIsNotNone(response_iterator.trailing_metadata())
+    def testCancelledUnaryRequestStreamResponseNonBlocking(self):
+        self._cancelled_unary_request_stream_response(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testCancelledStreamRequestUnaryResponse(self):
         requests = tuple(
@@ -543,23 +576,12 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(response_future.trailing_metadata())
 
     def testCancelledStreamRequestStreamResponse(self):
-        requests = tuple(
-            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
-        request_iterator = iter(requests)
+        self._cancelled_stream_request_stream_response(
+            _stream_stream_multi_callable(self._channel))
 
-        multi_callable = _stream_stream_multi_callable(self._channel)
-        with self._control.pause():
-            response_iterator = multi_callable(
-                request_iterator,
-                metadata=(('test', 'CancelledStreamRequestStreamResponse'),))
-            response_iterator.cancel()
-
-        with self.assertRaises(grpc.RpcError):
-            next(response_iterator)
-        self.assertIsNotNone(response_iterator.initial_metadata())
-        self.assertIs(grpc.StatusCode.CANCELLED, response_iterator.code())
-        self.assertIsNotNone(response_iterator.details())
-        self.assertIsNotNone(response_iterator.trailing_metadata())
+    def testCancelledStreamRequestStreamResponseNonBlocking(self):
+        self._cancelled_stream_request_stream_response(
+            _stream_stream_non_blocking_multi_callable(self._channel))
 
     def testExpiredUnaryRequestBlockingUnaryResponse(self):
         request = b'\x07\x17'
@@ -608,21 +630,12 @@ class RPCTest(unittest.TestCase):
                       response_future.exception().code())
 
     def testExpiredUnaryRequestStreamResponse(self):
-        request = b'\x07\x19'
+        self._expired_unary_request_stream_response(
+            _unary_stream_multi_callable(self._channel))
 
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        with self._control.pause():
-            with self.assertRaises(grpc.RpcError) as exception_context:
-                response_iterator = multi_callable(
-                    request,
-                    timeout=test_constants.SHORT_TIMEOUT,
-                    metadata=(('test', 'ExpiredUnaryRequestStreamResponse'),))
-                next(response_iterator)
-
-        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
-                      exception_context.exception.code())
-        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
-                      response_iterator.code())
+    def testExpiredUnaryRequestStreamResponseNonBlocking(self):
+        self._expired_unary_request_stream_response(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testExpiredStreamRequestBlockingUnaryResponse(self):
         requests = tuple(
@@ -678,23 +691,12 @@ class RPCTest(unittest.TestCase):
         self.assertIsNotNone(response_future.trailing_metadata())
 
     def testExpiredStreamRequestStreamResponse(self):
-        requests = tuple(
-            b'\x67\x18' for _ in range(test_constants.STREAM_LENGTH))
-        request_iterator = iter(requests)
-
-        multi_callable = _stream_stream_multi_callable(self._channel)
-        with self._control.pause():
-            with self.assertRaises(grpc.RpcError) as exception_context:
-                response_iterator = multi_callable(
-                    request_iterator,
-                    timeout=test_constants.SHORT_TIMEOUT,
-                    metadata=(('test', 'ExpiredStreamRequestStreamResponse'),))
-                next(response_iterator)
+        self._expired_stream_request_stream_response(
+            _stream_stream_multi_callable(self._channel))
 
-        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
-                      exception_context.exception.code())
-        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
-                      response_iterator.code())
+    def testExpiredStreamRequestStreamResponseNonBlocking(self):
+        self._expired_stream_request_stream_response(
+            _stream_stream_non_blocking_multi_callable(self._channel))
 
     def testFailedUnaryRequestBlockingUnaryResponse(self):
         request = b'\x37\x17'
@@ -712,10 +714,10 @@ class RPCTest(unittest.TestCase):
         # sanity checks on to make sure returned string contains default members
         # of the error
         debug_error_string = exception_context.exception.debug_error_string()
-        self.assertIn("created", debug_error_string)
-        self.assertIn("description", debug_error_string)
-        self.assertIn("file", debug_error_string)
-        self.assertIn("file_line", debug_error_string)
+        self.assertIn('created', debug_error_string)
+        self.assertIn('description', debug_error_string)
+        self.assertIn('file', debug_error_string)
+        self.assertIn('file_line', debug_error_string)
 
     def testFailedUnaryRequestFutureUnaryResponse(self):
         request = b'\x37\x17'
@@ -742,18 +744,12 @@ class RPCTest(unittest.TestCase):
         self.assertIs(response_future, value_passed_to_callback)
 
     def testFailedUnaryRequestStreamResponse(self):
-        request = b'\x37\x17'
+        self._failed_unary_request_stream_response(
+            _unary_stream_multi_callable(self._channel))
 
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        with self.assertRaises(grpc.RpcError) as exception_context:
-            with self._control.fail():
-                response_iterator = multi_callable(
-                    request,
-                    metadata=(('test', 'FailedUnaryRequestStreamResponse'),))
-                next(response_iterator)
-
-        self.assertIs(grpc.StatusCode.UNKNOWN,
-                      exception_context.exception.code())
+    def testFailedUnaryRequestStreamResponseNonBlocking(self):
+        self._failed_unary_request_stream_response(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testFailedStreamRequestBlockingUnaryResponse(self):
         requests = tuple(
@@ -795,21 +791,12 @@ class RPCTest(unittest.TestCase):
         self.assertIs(response_future, value_passed_to_callback)
 
     def testFailedStreamRequestStreamResponse(self):
-        requests = tuple(
-            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
-        request_iterator = iter(requests)
+        self._failed_stream_request_stream_response(
+            _stream_stream_multi_callable(self._channel))
 
-        multi_callable = _stream_stream_multi_callable(self._channel)
-        with self._control.fail():
-            with self.assertRaises(grpc.RpcError) as exception_context:
-                response_iterator = multi_callable(
-                    request_iterator,
-                    metadata=(('test', 'FailedStreamRequestStreamResponse'),))
-                tuple(response_iterator)
-
-        self.assertIs(grpc.StatusCode.UNKNOWN,
-                      exception_context.exception.code())
-        self.assertIs(grpc.StatusCode.UNKNOWN, response_iterator.code())
+    def testFailedStreamRequestStreamResponseNonBlocking(self):
+        self._failed_stream_request_stream_response(
+            _stream_stream_non_blocking_multi_callable(self._channel))
 
     def testIgnoredUnaryRequestFutureUnaryResponse(self):
         request = b'\x37\x17'
@@ -820,11 +807,12 @@ class RPCTest(unittest.TestCase):
             metadata=(('test', 'IgnoredUnaryRequestFutureUnaryResponse'),))
 
     def testIgnoredUnaryRequestStreamResponse(self):
-        request = b'\x37\x17'
+        self._ignored_unary_stream_request_future_unary_response(
+            _unary_stream_multi_callable(self._channel))
 
-        multi_callable = _unary_stream_multi_callable(self._channel)
-        multi_callable(
-            request, metadata=(('test', 'IgnoredUnaryRequestStreamResponse'),))
+    def testIgnoredUnaryRequestStreamResponseNonBlocking(self):
+        self._ignored_unary_stream_request_future_unary_response(
+            _unary_stream_non_blocking_multi_callable(self._channel))
 
     def testIgnoredStreamRequestFutureUnaryResponse(self):
         requests = tuple(
@@ -837,11 +825,177 @@ class RPCTest(unittest.TestCase):
             metadata=(('test', 'IgnoredStreamRequestFutureUnaryResponse'),))
 
     def testIgnoredStreamRequestStreamResponse(self):
+        self._ignored_stream_request_stream_response(
+            _stream_stream_multi_callable(self._channel))
+
+    def testIgnoredStreamRequestStreamResponseNonBlocking(self):
+        self._ignored_stream_request_stream_response(
+            _stream_stream_non_blocking_multi_callable(self._channel))
+
+    def _consume_one_stream_response_unary_request(self, multi_callable):
+        request = b'\x57\x38'
+
+        response_iterator = multi_callable(
+            request,
+            metadata=(('test', 'ConsumingOneStreamResponseUnaryRequest'),))
+        next(response_iterator)
+
+    def _consume_some_but_not_all_stream_responses_unary_request(
+            self, multi_callable):
+        request = b'\x57\x38'
+
+        response_iterator = multi_callable(
+            request,
+            metadata=(('test',
+                       'ConsumingSomeButNotAllStreamResponsesUnaryRequest'),))
+        for _ in range(test_constants.STREAM_LENGTH // 2):
+            next(response_iterator)
+
+    def _consume_some_but_not_all_stream_responses_stream_request(
+            self, multi_callable):
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = iter(requests)
+
+        response_iterator = multi_callable(
+            request_iterator,
+            metadata=(('test',
+                       'ConsumingSomeButNotAllStreamResponsesStreamRequest'),))
+        for _ in range(test_constants.STREAM_LENGTH // 2):
+            next(response_iterator)
+
+    def _consume_too_many_stream_responses_stream_request(self, multi_callable):
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = iter(requests)
+
+        response_iterator = multi_callable(
+            request_iterator,
+            metadata=(('test',
+                       'ConsumingTooManyStreamResponsesStreamRequest'),))
+        for _ in range(test_constants.STREAM_LENGTH):
+            next(response_iterator)
+        for _ in range(test_constants.STREAM_LENGTH):
+            with self.assertRaises(StopIteration):
+                next(response_iterator)
+
+        self.assertIsNotNone(response_iterator.initial_metadata())
+        self.assertIs(grpc.StatusCode.OK, response_iterator.code())
+        self.assertIsNotNone(response_iterator.details())
+        self.assertIsNotNone(response_iterator.trailing_metadata())
+
+    def _cancelled_unary_request_stream_response(self, multi_callable):
+        request = b'\x07\x19'
+
+        with self._control.pause():
+            response_iterator = multi_callable(
+                request,
+                metadata=(('test', 'CancelledUnaryRequestStreamResponse'),))
+            self._control.block_until_paused()
+            response_iterator.cancel()
+
+        with self.assertRaises(grpc.RpcError) as exception_context:
+            next(response_iterator)
+        self.assertIs(grpc.StatusCode.CANCELLED,
+                      exception_context.exception.code())
+        self.assertIsNotNone(response_iterator.initial_metadata())
+        self.assertIs(grpc.StatusCode.CANCELLED, response_iterator.code())
+        self.assertIsNotNone(response_iterator.details())
+        self.assertIsNotNone(response_iterator.trailing_metadata())
+
+    def _cancelled_stream_request_stream_response(self, multi_callable):
+        requests = tuple(
+            b'\x07\x08' for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = iter(requests)
+
+        with self._control.pause():
+            response_iterator = multi_callable(
+                request_iterator,
+                metadata=(('test', 'CancelledStreamRequestStreamResponse'),))
+            response_iterator.cancel()
+
+        with self.assertRaises(grpc.RpcError):
+            next(response_iterator)
+        self.assertIsNotNone(response_iterator.initial_metadata())
+        self.assertIs(grpc.StatusCode.CANCELLED, response_iterator.code())
+        self.assertIsNotNone(response_iterator.details())
+        self.assertIsNotNone(response_iterator.trailing_metadata())
+
+    def _expired_unary_request_stream_response(self, multi_callable):
+        request = b'\x07\x19'
+
+        with self._control.pause():
+            with self.assertRaises(grpc.RpcError) as exception_context:
+                response_iterator = multi_callable(
+                    request,
+                    timeout=test_constants.SHORT_TIMEOUT,
+                    metadata=(('test', 'ExpiredUnaryRequestStreamResponse'),))
+                next(response_iterator)
+
+        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
+                      exception_context.exception.code())
+        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
+                      response_iterator.code())
+
+    def _expired_stream_request_stream_response(self, multi_callable):
+        requests = tuple(
+            b'\x67\x18' for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = iter(requests)
+
+        with self._control.pause():
+            with self.assertRaises(grpc.RpcError) as exception_context:
+                response_iterator = multi_callable(
+                    request_iterator,
+                    timeout=test_constants.SHORT_TIMEOUT,
+                    metadata=(('test', 'ExpiredStreamRequestStreamResponse'),))
+                next(response_iterator)
+
+        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
+                      exception_context.exception.code())
+        self.assertIs(grpc.StatusCode.DEADLINE_EXCEEDED,
+                      response_iterator.code())
+
+    def _failed_unary_request_stream_response(self, multi_callable):
+        request = b'\x37\x17'
+
+        with self.assertRaises(grpc.RpcError) as exception_context:
+            with self._control.fail():
+                response_iterator = multi_callable(
+                    request,
+                    metadata=(('test', 'FailedUnaryRequestStreamResponse'),))
+                next(response_iterator)
+
+        self.assertIs(grpc.StatusCode.UNKNOWN,
+                      exception_context.exception.code())
+
+    def _failed_stream_request_stream_response(self, multi_callable):
+        requests = tuple(
+            b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
+        request_iterator = iter(requests)
+
+        with self._control.fail():
+            with self.assertRaises(grpc.RpcError) as exception_context:
+                response_iterator = multi_callable(
+                    request_iterator,
+                    metadata=(('test', 'FailedStreamRequestStreamResponse'),))
+                tuple(response_iterator)
+
+        self.assertIs(grpc.StatusCode.UNKNOWN,
+                      exception_context.exception.code())
+        self.assertIs(grpc.StatusCode.UNKNOWN, response_iterator.code())
+
+    def _ignored_unary_stream_request_future_unary_response(
+            self, multi_callable):
+        request = b'\x37\x17'
+
+        multi_callable(
+            request, metadata=(('test', 'IgnoredUnaryRequestStreamResponse'),))
+
+    def _ignored_stream_request_stream_response(self, multi_callable):
         requests = tuple(
             b'\x67\x88' for _ in range(test_constants.STREAM_LENGTH))
         request_iterator = iter(requests)
 
-        multi_callable = _stream_stream_multi_callable(self._channel)
         multi_callable(
             request_iterator,
             metadata=(('test', 'IgnoredStreamRequestStreamResponse'),))

src/python/grpcio_tests/tests/unit/_thread_pool.py → src/python/grpcio_tests/tests/unit/thread_pool.py

@@ -16,7 +16,7 @@ import threading
 from concurrent import futures
 
 
-class RecordingThreadPool(futures.Executor):
+class RecordingThreadPool(futures.ThreadPoolExecutor):
     """A thread pool that records if used."""
 
     def __init__(self, max_workers):

test/core/channel/channel_stack_builder_test.cc

@@ -45,16 +45,6 @@ static void call_destroy_func(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {}
 
-static void call_func(grpc_call_element* elem,
-                      grpc_transport_stream_op_batch* op) {}
-
-static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) {
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    GRPC_ERROR_UNREF(op->disconnect_with_error);
-  }
-  GRPC_CLOSURE_SCHED(op->on_consumed, GRPC_ERROR_NONE);
-}
-
 bool g_replacement_fn_called = false;
 bool g_original_fn_called = false;
 void set_arg_once_fn(grpc_channel_stack* channel_stack,
@@ -77,8 +67,8 @@ static void test_channel_stack_builder_filter_replace(void) {
 }
 
 const grpc_channel_filter replacement_filter = {
-    call_func,
-    channel_func,
+    grpc_call_next_op,
+    grpc_channel_next_op,
     0,
     call_init_func,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,
@@ -90,8 +80,8 @@ const grpc_channel_filter replacement_filter = {
     "filter_name"};
 
 const grpc_channel_filter original_filter = {
-    call_func,
-    channel_func,
+    grpc_call_next_op,
+    grpc_channel_next_op,
     0,
     call_init_func,
     grpc_call_stack_ignore_set_pollset_or_pollset_set,

test/core/util/test_lb_policies.cc

@@ -48,61 +48,25 @@ namespace {
 // A minimal forwarding class to avoid implementing a standalone test LB.
 class ForwardingLoadBalancingPolicy : public LoadBalancingPolicy {
  public:
-  ForwardingLoadBalancingPolicy(Args args,
-                                const std::string& delegate_policy_name)
-      : LoadBalancingPolicy(std::move(args)) {
+  ForwardingLoadBalancingPolicy(
+      UniquePtr<ChannelControlHelper> delegating_helper, Args args,
+      const std::string& delegate_policy_name, intptr_t initial_refcount = 1)
+      : LoadBalancingPolicy(std::move(args), initial_refcount) {
     Args delegate_args;
     delegate_args.combiner = combiner();
-    delegate_args.client_channel_factory = client_channel_factory();
-    delegate_args.subchannel_pool = subchannel_pool()->Ref();
+    delegate_args.channel_control_helper = std::move(delegating_helper);
     delegate_args.args = args.args;
-    delegate_args.lb_config = args.lb_config;
     delegate_ = LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
         delegate_policy_name.c_str(), std::move(delegate_args));
     grpc_pollset_set_add_pollset_set(delegate_->interested_parties(),
                                      interested_parties());
-    // Give re-resolution closure to delegate.
-    GRPC_CLOSURE_INIT(&on_delegate_request_reresolution_,
-                      OnDelegateRequestReresolutionLocked, this,
-                      grpc_combiner_scheduler(combiner()));
-    Ref().release();  // held by callback.
-    delegate_->SetReresolutionClosureLocked(&on_delegate_request_reresolution_);
   }
 
   ~ForwardingLoadBalancingPolicy() override = default;
 
   void UpdateLocked(const grpc_channel_args& args,
-                    grpc_json* lb_config) override {
-    delegate_->UpdateLocked(args, lb_config);
-  }
-
-  bool PickLocked(PickState* pick, grpc_error** error) override {
-    return delegate_->PickLocked(pick, error);
-  }
-
-  void CancelPickLocked(PickState* pick, grpc_error* error) override {
-    delegate_->CancelPickLocked(pick, error);
-  }
-
-  void CancelMatchingPicksLocked(uint32_t initial_metadata_flags_mask,
-                                 uint32_t initial_metadata_flags_eq,
-                                 grpc_error* error) override {
-    delegate_->CancelMatchingPicksLocked(initial_metadata_flags_mask,
-                                         initial_metadata_flags_eq, error);
-  }
-
-  void NotifyOnStateChangeLocked(grpc_connectivity_state* state,
-                                 grpc_closure* closure) override {
-    delegate_->NotifyOnStateChangeLocked(state, closure);
-  }
-
-  grpc_connectivity_state CheckConnectivityLocked(
-      grpc_error** connectivity_error) override {
-    return delegate_->CheckConnectivityLocked(connectivity_error);
-  }
-
-  void HandOffPendingPicksLocked(LoadBalancingPolicy* new_policy) override {
-    delegate_->HandOffPendingPicksLocked(new_policy);
+                    RefCountedPtr<Config> lb_config) override {
+    delegate_->UpdateLocked(args, std::move(lb_config));
   }
 
   void ExitIdleLocked() override { delegate_->ExitIdleLocked(); }
@@ -116,26 +80,9 @@ class ForwardingLoadBalancingPolicy : public LoadBalancingPolicy {
   }
 
  private:
-  void ShutdownLocked() override {
-    delegate_.reset();
-    TryReresolutionLocked(&grpc_trace_forwarding_lb, GRPC_ERROR_CANCELLED);
-  }
-
-  static void OnDelegateRequestReresolutionLocked(void* arg,
-                                                  grpc_error* error) {
-    ForwardingLoadBalancingPolicy* self =
-        static_cast<ForwardingLoadBalancingPolicy*>(arg);
-    if (error != GRPC_ERROR_NONE || self->delegate_ == nullptr) {
-      self->Unref();
-      return;
-    }
-    self->TryReresolutionLocked(&grpc_trace_forwarding_lb, GRPC_ERROR_NONE);
-    self->delegate_->SetReresolutionClosureLocked(
-        &self->on_delegate_request_reresolution_);
-  }
+  void ShutdownLocked() override { delegate_.reset(); }
 
   OrphanablePtr<LoadBalancingPolicy> delegate_;
-  grpc_closure on_delegate_request_reresolution_;
 };
 
 //
@@ -150,10 +97,14 @@ class InterceptRecvTrailingMetadataLoadBalancingPolicy
  public:
   InterceptRecvTrailingMetadataLoadBalancingPolicy(
       Args args, InterceptRecvTrailingMetadataCallback cb, void* user_data)
-      : ForwardingLoadBalancingPolicy(std::move(args),
-                                      /*delegate_lb_policy_name=*/"pick_first"),
-        cb_(cb),
-        user_data_(user_data) {}
+      : ForwardingLoadBalancingPolicy(
+            UniquePtr<ChannelControlHelper>(New<Helper>(
+                RefCountedPtr<InterceptRecvTrailingMetadataLoadBalancingPolicy>(
+                    this),
+                cb, user_data)),
+            std::move(args),
+            /*delegate_lb_policy_name=*/"pick_first",
+            /*initial_refcount=*/2) {}
 
   ~InterceptRecvTrailingMetadataLoadBalancingPolicy() override = default;
 
@@ -161,17 +112,65 @@ class InterceptRecvTrailingMetadataLoadBalancingPolicy
     return kInterceptRecvTrailingMetadataLbPolicyName;
   }
 
-  bool PickLocked(PickState* pick, grpc_error** error) override {
-    bool ret = ForwardingLoadBalancingPolicy::PickLocked(pick, error);
-    // Note: This assumes that the delegate policy does not
-    // intercepting recv_trailing_metadata.  If we ever need to use
-    // this with a delegate policy that does, then we'll need to
-    // handle async pick returns separately.
-    New<TrailingMetadataHandler>(pick, cb_, user_data_);  // deletes itself
-    return ret;
-  }
-
  private:
+  class Picker : public SubchannelPicker {
+   public:
+    explicit Picker(UniquePtr<SubchannelPicker> delegate_picker,
+                    InterceptRecvTrailingMetadataCallback cb, void* user_data)
+        : delegate_picker_(std::move(delegate_picker)),
+          cb_(cb),
+          user_data_(user_data) {}
+
+    PickResult Pick(PickState* pick, grpc_error** error) override {
+      PickResult result = delegate_picker_->Pick(pick, error);
+      if (result == PICK_COMPLETE && pick->connected_subchannel != nullptr) {
+        New<TrailingMetadataHandler>(pick, cb_, user_data_);  // deletes itself
+      }
+      return result;
+    }
+
+   private:
+    UniquePtr<SubchannelPicker> delegate_picker_;
+    InterceptRecvTrailingMetadataCallback cb_;
+    void* user_data_;
+  };
+
+  class Helper : public ChannelControlHelper {
+   public:
+    Helper(
+        RefCountedPtr<InterceptRecvTrailingMetadataLoadBalancingPolicy> parent,
+        InterceptRecvTrailingMetadataCallback cb, void* user_data)
+        : parent_(std::move(parent)), cb_(cb), user_data_(user_data) {}
+
+    Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
+      return parent_->channel_control_helper()->CreateSubchannel(args);
+    }
+
+    grpc_channel* CreateChannel(const char* target,
+                                grpc_client_channel_type type,
+                                const grpc_channel_args& args) override {
+      return parent_->channel_control_helper()->CreateChannel(target, type,
+                                                              args);
+    }
+
+    void UpdateState(grpc_connectivity_state state, grpc_error* state_error,
+                     UniquePtr<SubchannelPicker> picker) override {
+      parent_->channel_control_helper()->UpdateState(
+          state, state_error,
+          UniquePtr<SubchannelPicker>(
+              New<Picker>(std::move(picker), cb_, user_data_)));
+    }
+
+    void RequestReresolution() override {
+      parent_->channel_control_helper()->RequestReresolution();
+    }
+
+   private:
+    RefCountedPtr<InterceptRecvTrailingMetadataLoadBalancingPolicy> parent_;
+    InterceptRecvTrailingMetadataCallback cb_;
+    void* user_data_;
+  };
+
   class TrailingMetadataHandler {
    public:
     TrailingMetadataHandler(PickState* pick,
@@ -204,9 +203,6 @@ class InterceptRecvTrailingMetadataLoadBalancingPolicy
     grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
     grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
   };
-
-  InterceptRecvTrailingMetadataCallback cb_;
-  void* user_data_;
 };
 
 class InterceptTrailingFactory : public LoadBalancingPolicyFactory {
@@ -215,12 +211,11 @@ class InterceptTrailingFactory : public LoadBalancingPolicyFactory {
                                     void* user_data)
       : cb_(cb), user_data_(user_data) {}
 
-  grpc_core::OrphanablePtr<grpc_core::LoadBalancingPolicy>
-  CreateLoadBalancingPolicy(
-      grpc_core::LoadBalancingPolicy::Args args) const override {
-    return grpc_core::OrphanablePtr<grpc_core::LoadBalancingPolicy>(
-        grpc_core::New<InterceptRecvTrailingMetadataLoadBalancingPolicy>(
-            std::move(args), cb_, user_data_));
+  OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
+      LoadBalancingPolicy::Args args) const override {
+    return OrphanablePtr<LoadBalancingPolicy>(
+        New<InterceptRecvTrailingMetadataLoadBalancingPolicy>(std::move(args),
+                                                              cb_, user_data_));
   }
 
   const char* name() const override {
@@ -236,10 +231,9 @@ class InterceptTrailingFactory : public LoadBalancingPolicyFactory {
 
 void RegisterInterceptRecvTrailingMetadataLoadBalancingPolicy(
     InterceptRecvTrailingMetadataCallback cb, void* user_data) {
-  grpc_core::LoadBalancingPolicyRegistry::Builder::
-      RegisterLoadBalancingPolicyFactory(
-          grpc_core::UniquePtr<grpc_core::LoadBalancingPolicyFactory>(
-              grpc_core::New<InterceptTrailingFactory>(cb, user_data)));
+  LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
+      UniquePtr<LoadBalancingPolicyFactory>(
+          New<InterceptTrailingFactory>(cb, user_data)));
 }
 
 }  // namespace grpc_core

test/cpp/end2end/BUILD

@@ -150,6 +150,7 @@ grpc_cc_test(
         "gtest",
     ],
     deps = [
+        ":interceptors_util",
         ":test_service_impl",
         "//:gpr",
         "//:grpc",
@@ -553,6 +554,25 @@ grpc_cc_test(
     ],
 )
 
+grpc_cc_test(
+    name = "flaky_network_test",
+    srcs = ["flaky_network_test.cc"],
+    external_deps = [
+        "gtest",
+    ],
+    tags = ["manual"],
+    deps = [
+        ":test_service_impl",
+        "//:gpr",
+        "//:grpc",
+        "//:grpc++",
+        "//src/proto/grpc/testing:echo_messages_proto",
+        "//src/proto/grpc/testing:echo_proto",
+        "//test/core/util:grpc_test_util",
+        "//test/cpp/util:test_util",
+    ],
+)
+
 grpc_cc_test(
     name = "shutdown_test",
     srcs = ["shutdown_test.cc"],
@@ -606,3 +626,23 @@ grpc_cc_test(
         "//test/cpp/util:test_util",
     ],
 )
+
+grpc_cc_test(
+    name = "cfstream_test",
+    srcs = ["cfstream_test.cc"],
+    external_deps = [
+        "gtest",
+    ],
+    tags = ["manual"],  # test requires root, won't work with bazel RBE
+    deps = [
+        ":test_service_impl",
+        "//:gpr",
+        "//:grpc",
+        "//:grpc++",
+        "//src/proto/grpc/testing:echo_messages_proto",
+        "//src/proto/grpc/testing:echo_proto",
+        "//src/proto/grpc/testing:simple_messages_proto",
+        "//test/core/util:grpc_test_util",
+        "//test/cpp/util:test_util",
+    ],
+)

test/cpp/end2end/cfstream_test.cc

@@ -0,0 +1,278 @@
+/*
+ *
+ * Copyright 2019 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/iomgr/port.h"
+
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <random>
+#include <thread>
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/health_check_service_interface.h>
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+#include <gtest/gtest.h>
+
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/gpr/env.h"
+
+#include "src/proto/grpc/testing/echo.grpc.pb.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+#include "test/cpp/end2end/test_service_impl.h"
+
+#ifdef GRPC_CFSTREAM
+using grpc::testing::EchoRequest;
+using grpc::testing::EchoResponse;
+using std::chrono::system_clock;
+
+namespace grpc {
+namespace testing {
+namespace {
+
+class CFStreamTest : public ::testing::Test {
+ protected:
+  CFStreamTest()
+      : server_host_("grpctest"),
+        interface_("lo0"),
+        ipv4_address_("10.0.0.1"),
+        netmask_("/32"),
+        kRequestMessage_("🖖") {}
+
+  void DNSUp() {
+    std::ostringstream cmd;
+    // Add DNS entry for server_host_ in /etc/hosts
+    cmd << "echo '" << ipv4_address_ << "      " << server_host_
+        << "  ' | sudo tee -a /etc/hosts";
+    std::system(cmd.str().c_str());
+  }
+
+  void DNSDown() {
+    std::ostringstream cmd;
+    // Remove DNS entry for server_host_ in /etc/hosts
+    cmd << "sudo sed -i '.bak' '/" << server_host_ << "/d' /etc/hosts";
+    std::system(cmd.str().c_str());
+  }
+
+  void InterfaceUp() {
+    std::ostringstream cmd;
+    cmd << "sudo /sbin/ifconfig " << interface_ << " alias " << ipv4_address_;
+    std::system(cmd.str().c_str());
+  }
+
+  void InterfaceDown() {
+    std::ostringstream cmd;
+    cmd << "sudo /sbin/ifconfig " << interface_ << " -alias " << ipv4_address_;
+    std::system(cmd.str().c_str());
+  }
+
+  void NetworkUp() {
+    InterfaceUp();
+    DNSUp();
+  }
+
+  void NetworkDown() {
+    InterfaceDown();
+    DNSDown();
+  }
+
+  void SetUp() override {
+    NetworkUp();
+    grpc_init();
+    StartServer();
+  }
+
+  void TearDown() override {
+    NetworkDown();
+    StopServer();
+    grpc_shutdown();
+  }
+
+  void StartServer() {
+    port_ = grpc_pick_unused_port_or_die();
+    server_.reset(new ServerData(port_));
+    server_->Start(server_host_);
+  }
+  void StopServer() { server_->Shutdown(); }
+
+  std::unique_ptr<grpc::testing::EchoTestService::Stub> BuildStub(
+      const std::shared_ptr<Channel>& channel) {
+    return grpc::testing::EchoTestService::NewStub(channel);
+  }
+
+  std::shared_ptr<Channel> BuildChannel() {
+    std::ostringstream server_address;
+    server_address << server_host_ << ":" << port_;
+    return CreateCustomChannel(
+        server_address.str(), InsecureChannelCredentials(), ChannelArguments());
+  }
+
+  void SendRpc(
+      const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub,
+      bool expect_success = false) {
+    auto response = std::unique_ptr<EchoResponse>(new EchoResponse());
+    EchoRequest request;
+    request.set_message(kRequestMessage_);
+    ClientContext context;
+    Status status = stub->Echo(&context, request, response.get());
+    if (status.ok()) {
+      gpr_log(GPR_DEBUG, "RPC returned %s\n", response->message().c_str());
+    } else {
+      gpr_log(GPR_DEBUG, "RPC failed: %s", status.error_message().c_str());
+    }
+    if (expect_success) {
+      EXPECT_TRUE(status.ok());
+    }
+  }
+
+  bool WaitForChannelNotReady(Channel* channel, int timeout_seconds = 5) {
+    const gpr_timespec deadline =
+        grpc_timeout_seconds_to_deadline(timeout_seconds);
+    grpc_connectivity_state state;
+    while ((state = channel->GetState(false /* try_to_connect */)) ==
+           GRPC_CHANNEL_READY) {
+      if (!channel->WaitForStateChange(state, deadline)) return false;
+    }
+    return true;
+  }
+
+  bool WaitForChannelReady(Channel* channel, int timeout_seconds = 10) {
+    const gpr_timespec deadline =
+        grpc_timeout_seconds_to_deadline(timeout_seconds);
+    grpc_connectivity_state state;
+    while ((state = channel->GetState(true /* try_to_connect */)) !=
+           GRPC_CHANNEL_READY) {
+      if (!channel->WaitForStateChange(state, deadline)) return false;
+    }
+    return true;
+  }
+
+ private:
+  struct ServerData {
+    int port_;
+    std::unique_ptr<Server> server_;
+    TestServiceImpl service_;
+    std::unique_ptr<std::thread> thread_;
+    bool server_ready_ = false;
+
+    explicit ServerData(int port) { port_ = port; }
+
+    void Start(const grpc::string& server_host) {
+      gpr_log(GPR_INFO, "starting server on port %d", port_);
+      std::mutex mu;
+      std::unique_lock<std::mutex> lock(mu);
+      std::condition_variable cond;
+      thread_.reset(new std::thread(
+          std::bind(&ServerData::Serve, this, server_host, &mu, &cond)));
+      cond.wait(lock, [this] { return server_ready_; });
+      server_ready_ = false;
+      gpr_log(GPR_INFO, "server startup complete");
+    }
+
+    void Serve(const grpc::string& server_host, std::mutex* mu,
+               std::condition_variable* cond) {
+      std::ostringstream server_address;
+      server_address << server_host << ":" << port_;
+      ServerBuilder builder;
+      builder.AddListeningPort(server_address.str(),
+                               InsecureServerCredentials());
+      builder.RegisterService(&service_);
+      server_ = builder.BuildAndStart();
+      std::lock_guard<std::mutex> lock(*mu);
+      server_ready_ = true;
+      cond->notify_one();
+    }
+
+    void Shutdown(bool join = true) {
+      server_->Shutdown(grpc_timeout_milliseconds_to_deadline(0));
+      if (join) thread_->join();
+    }
+  };
+
+  const grpc::string server_host_;
+  const grpc::string interface_;
+  const grpc::string ipv4_address_;
+  const grpc::string netmask_;
+  std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
+  std::unique_ptr<ServerData> server_;
+  int port_;
+  const grpc::string kRequestMessage_;
+};
+
+// gRPC should automatically detech network flaps (without enabling keepalives)
+//  when CFStream is enabled
+TEST_F(CFStreamTest, NetworkTransition) {
+  auto channel = BuildChannel();
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  SendRpc(stub, /*expect_success=*/true);
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  std::atomic_bool shutdown{false};
+  std::thread sender = std::thread([this, &stub, &shutdown]() {
+    while (true) {
+      if (shutdown.load()) {
+        return;
+      }
+      SendRpc(stub);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+  });
+
+  // bring down network
+  NetworkDown();
+
+  // network going down should be detected by cfstream
+  EXPECT_TRUE(WaitForChannelNotReady(channel.get()));
+
+  // bring network interface back up
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  NetworkUp();
+
+  // channel should reconnect
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+  shutdown.store(true);
+  sender.join();
+}
+
+}  // namespace
+}  // namespace testing
+}  // namespace grpc
+#endif  // GRPC_CFSTREAM
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  grpc_test_init(argc, argv);
+  gpr_setenv("grpc_cfstream", "1");
+  // TODO (pjaikumar): remove the line below when
+  // https://github.com/grpc/grpc/issues/18080 has been fixed.
+  gpr_setenv("GRPC_DNS_RESOLVER", "native");
+  const auto result = RUN_ALL_TESTS();
+  return result;
+}

test/cpp/end2end/client_callback_end2end_test.cc

@@ -16,6 +16,7 @@
  *
  */
 
+#include <algorithm>
 #include <functional>
 #include <mutex>
 #include <sstream>
@@ -35,9 +36,11 @@
 #include "src/proto/grpc/testing/echo.grpc.pb.h"
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
+#include "test/cpp/end2end/interceptors_util.h"
 #include "test/cpp/end2end/test_service_impl.h"
 #include "test/cpp/util/byte_buffer_proto_helper.h"
 #include "test/cpp/util/string_ref_helper.h"
+#include "test/cpp/util/test_credentials_provider.h"
 
 #include <gtest/gtest.h>
 
@@ -60,11 +63,17 @@ enum class Protocol { INPROC, TCP };
 
 class TestScenario {
  public:
-  TestScenario(bool serve_callback, Protocol protocol)
-      : callback_server(serve_callback), protocol(protocol) {}
+  TestScenario(bool serve_callback, Protocol protocol, bool intercept,
+               const grpc::string& creds_type)
+      : callback_server(serve_callback),
+        protocol(protocol),
+        use_interceptors(intercept),
+        credentials_type(creds_type) {}
   void Log() const;
   bool callback_server;
   Protocol protocol;
+  bool use_interceptors;
+  const grpc::string credentials_type;
 };
 
 static std::ostream& operator<<(std::ostream& out,
@@ -87,15 +96,18 @@ class ClientCallbackEnd2endTest
   void SetUp() override {
     ServerBuilder builder;
 
+    auto server_creds = GetCredentialsProvider()->GetServerCredentials(
+        GetParam().credentials_type);
+    // TODO(vjpai): Support testing of AuthMetadataProcessor
+
     if (GetParam().protocol == Protocol::TCP) {
       if (!grpc_iomgr_run_in_background()) {
         do_not_test_ = true;
         return;
       }
-      int port = grpc_pick_unused_port_or_die();
-      server_address_ << "localhost:" << port;
-      builder.AddListeningPort(server_address_.str(),
-                               InsecureServerCredentials());
+      picked_port_ = grpc_pick_unused_port_or_die();
+      server_address_ << "localhost:" << picked_port_;
+      builder.AddListeningPort(server_address_.str(), server_creds);
     }
     if (!GetParam().callback_server) {
       builder.RegisterService(&service_);
@@ -103,31 +115,61 @@ class ClientCallbackEnd2endTest
       builder.RegisterService(&callback_service_);
     }
 
+    if (GetParam().use_interceptors) {
+      std::vector<
+          std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
+          creators;
+      // Add 20 dummy server interceptors
+      creators.reserve(20);
+      for (auto i = 0; i < 20; i++) {
+        creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
+            new DummyInterceptorFactory()));
+      }
+      builder.experimental().SetInterceptorCreators(std::move(creators));
+    }
+
     server_ = builder.BuildAndStart();
     is_server_started_ = true;
   }
 
   void ResetStub() {
     ChannelArguments args;
+    auto channel_creds = GetCredentialsProvider()->GetChannelCredentials(
+        GetParam().credentials_type, &args);
     switch (GetParam().protocol) {
       case Protocol::TCP:
-        channel_ =
-            CreateChannel(server_address_.str(), InsecureChannelCredentials());
+        if (!GetParam().use_interceptors) {
+          channel_ =
+              CreateCustomChannel(server_address_.str(), channel_creds, args);
+        } else {
+          channel_ = CreateCustomChannelWithInterceptors(
+              server_address_.str(), channel_creds, args,
+              CreateDummyClientInterceptors());
+        }
         break;
       case Protocol::INPROC:
-        channel_ = server_->InProcessChannel(args);
+        if (!GetParam().use_interceptors) {
+          channel_ = server_->InProcessChannel(args);
+        } else {
+          channel_ = server_->experimental().InProcessChannelWithInterceptors(
+              args, CreateDummyClientInterceptors());
+        }
         break;
       default:
         assert(false);
     }
     stub_ = grpc::testing::EchoTestService::NewStub(channel_);
     generic_stub_.reset(new GenericStub(channel_));
+    DummyInterceptor::Reset();
   }
 
   void TearDown() override {
     if (is_server_started_) {
       server_->Shutdown();
     }
+    if (picked_port_ > 0) {
+      grpc_recycle_unused_port(picked_port_);
+    }
   }
 
   void SendRpcs(int num_rpcs, bool with_binary_metadata) {
@@ -283,6 +325,7 @@ class ClientCallbackEnd2endTest
   }
   bool do_not_test_{false};
   bool is_server_started_{false};
+  int picked_port_{0};
   std::shared_ptr<Channel> channel_;
   std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
   std::unique_ptr<grpc::GenericStub> generic_stub_;
@@ -419,136 +462,569 @@ TEST_P(ClientCallbackEnd2endTest, CancelRpcBeforeStart) {
   while (!done) {
     cv.wait(l);
   }
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
 }
 
-TEST_P(ClientCallbackEnd2endTest, RequestStream) {
+TEST_P(ClientCallbackEnd2endTest, RequestEchoServerCancel) {
   MAYBE_SKIP_TEST;
   ResetStub();
-  class Client : public grpc::experimental::ClientWriteReactor<EchoRequest> {
-   public:
-    explicit Client(grpc::testing::EchoTestService::Stub* stub) {
-      context_.set_initial_metadata_corked(true);
-      stub->experimental_async()->RequestStream(&context_, &response_, this);
-      StartCall();
-      request_.set_message("Hello server.");
-      StartWrite(&request_);
+  EchoRequest request;
+  EchoResponse response;
+  ClientContext context;
+  request.set_message("hello");
+  context.AddMetadata(kServerTryCancelRequest,
+                      grpc::to_string(CANCEL_BEFORE_PROCESSING));
+
+  std::mutex mu;
+  std::condition_variable cv;
+  bool done = false;
+  stub_->experimental_async()->Echo(
+      &context, &request, &response, [&done, &mu, &cv](Status s) {
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        std::lock_guard<std::mutex> l(mu);
+        done = true;
+        cv.notify_one();
+      });
+  std::unique_lock<std::mutex> l(mu);
+  while (!done) {
+    cv.wait(l);
+  }
+}
+
+struct ClientCancelInfo {
+  bool cancel{false};
+  int ops_before_cancel;
+  ClientCancelInfo() : cancel{false} {}
+  // Allow the single-op version to be non-explicit for ease of use
+  ClientCancelInfo(int ops) : cancel{true}, ops_before_cancel{ops} {}
+};
+
+class WriteClient : public grpc::experimental::ClientWriteReactor<EchoRequest> {
+ public:
+  WriteClient(grpc::testing::EchoTestService::Stub* stub,
+              ServerTryCancelRequestPhase server_try_cancel,
+              int num_msgs_to_send, ClientCancelInfo client_cancel = {})
+      : server_try_cancel_(server_try_cancel),
+        num_msgs_to_send_(num_msgs_to_send),
+        client_cancel_{client_cancel} {
+    grpc::string msg{"Hello server."};
+    for (int i = 0; i < num_msgs_to_send; i++) {
+      desired_ += msg;
     }
-    void OnWriteDone(bool ok) override {
-      writes_left_--;
-      if (writes_left_ > 1) {
-        StartWrite(&request_);
-      } else if (writes_left_ == 1) {
-        StartWriteLast(&request_, WriteOptions());
-      }
+    if (server_try_cancel != DO_NOT_CANCEL) {
+      // Send server_try_cancel value in the client metadata
+      context_.AddMetadata(kServerTryCancelRequest,
+                           grpc::to_string(server_try_cancel));
     }
-    void OnDone(const Status& s) override {
+    context_.set_initial_metadata_corked(true);
+    stub->experimental_async()->RequestStream(&context_, &response_, this);
+    StartCall();
+    request_.set_message(msg);
+    MaybeWrite();
+  }
+  void OnWriteDone(bool ok) override {
+    if (ok) {
+      num_msgs_sent_++;
+      MaybeWrite();
+    }
+  }
+  void OnDone(const Status& s) override {
+    gpr_log(GPR_INFO, "Sent %d messages", num_msgs_sent_);
+    int num_to_send =
+        (client_cancel_.cancel)
+            ? std::min(num_msgs_to_send_, client_cancel_.ops_before_cancel)
+            : num_msgs_to_send_;
+    switch (server_try_cancel_) {
+      case CANCEL_BEFORE_PROCESSING:
+      case CANCEL_DURING_PROCESSING:
+        // If the RPC is canceled by server before / during messages from the
+        // client, it means that the client most likely did not get a chance to
+        // send all the messages it wanted to send. i.e num_msgs_sent <=
+        // num_msgs_to_send
+        EXPECT_LE(num_msgs_sent_, num_to_send);
+        break;
+      case DO_NOT_CANCEL:
+      case CANCEL_AFTER_PROCESSING:
+        // If the RPC was not canceled or canceled after all messages were read
+        // by the server, the client did get a chance to send all its messages
+        EXPECT_EQ(num_msgs_sent_, num_to_send);
+        break;
+      default:
+        assert(false);
+        break;
+    }
+    if ((server_try_cancel_ == DO_NOT_CANCEL) && !client_cancel_.cancel) {
       EXPECT_TRUE(s.ok());
-      EXPECT_EQ(response_.message(), "Hello server.Hello server.Hello server.");
-      std::unique_lock<std::mutex> l(mu_);
-      done_ = true;
-      cv_.notify_one();
+      EXPECT_EQ(response_.message(), desired_);
+    } else {
+      EXPECT_FALSE(s.ok());
+      EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
     }
-    void Await() {
-      std::unique_lock<std::mutex> l(mu_);
-      while (!done_) {
-        cv_.wait(l);
-      }
+    std::unique_lock<std::mutex> l(mu_);
+    done_ = true;
+    cv_.notify_one();
+  }
+  void Await() {
+    std::unique_lock<std::mutex> l(mu_);
+    while (!done_) {
+      cv_.wait(l);
     }
+  }
 
-   private:
-    EchoRequest request_;
-    EchoResponse response_;
-    ClientContext context_;
-    int writes_left_{3};
-    std::mutex mu_;
-    std::condition_variable cv_;
-    bool done_ = false;
-  } test{stub_.get()};
+ private:
+  void MaybeWrite() {
+    if (client_cancel_.cancel &&
+        num_msgs_sent_ == client_cancel_.ops_before_cancel) {
+      context_.TryCancel();
+    } else if (num_msgs_to_send_ > num_msgs_sent_ + 1) {
+      StartWrite(&request_);
+    } else if (num_msgs_to_send_ == num_msgs_sent_ + 1) {
+      StartWriteLast(&request_, WriteOptions());
+    }
+  }
+  EchoRequest request_;
+  EchoResponse response_;
+  ClientContext context_;
+  const ServerTryCancelRequestPhase server_try_cancel_;
+  int num_msgs_sent_{0};
+  const int num_msgs_to_send_;
+  grpc::string desired_;
+  const ClientCancelInfo client_cancel_;
+  std::mutex mu_;
+  std::condition_variable cv_;
+  bool done_ = false;
+};
 
+TEST_P(ClientCallbackEnd2endTest, RequestStream) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  WriteClient test{stub_.get(), DO_NOT_CANCEL, 3};
   test.Await();
+  // Make sure that the server interceptors were not notified to cancel
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(0, DummyInterceptor::GetNumTimesCancel());
+  }
 }
 
-TEST_P(ClientCallbackEnd2endTest, ResponseStream) {
+TEST_P(ClientCallbackEnd2endTest, ClientCancelsRequestStream) {
   MAYBE_SKIP_TEST;
   ResetStub();
-  class Client : public grpc::experimental::ClientReadReactor<EchoResponse> {
-   public:
-    explicit Client(grpc::testing::EchoTestService::Stub* stub) {
-      request_.set_message("Hello client ");
-      stub->experimental_async()->ResponseStream(&context_, &request_, this);
-      StartCall();
-      StartRead(&response_);
+  WriteClient test{stub_.get(), DO_NOT_CANCEL, 3, {2}};
+  test.Await();
+  // Make sure that the server interceptors got the cancel
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel before doing reading the request
+TEST_P(ClientCallbackEnd2endTest, RequestStreamServerCancelBeforeReads) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  WriteClient test{stub_.get(), CANCEL_BEFORE_PROCESSING, 1};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel while reading a request from the stream in parallel
+TEST_P(ClientCallbackEnd2endTest, RequestStreamServerCancelDuringRead) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  WriteClient test{stub_.get(), CANCEL_DURING_PROCESSING, 10};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel after reading all the requests but before returning to the
+// client
+TEST_P(ClientCallbackEnd2endTest, RequestStreamServerCancelAfterReads) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  WriteClient test{stub_.get(), CANCEL_AFTER_PROCESSING, 4};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+class ReadClient : public grpc::experimental::ClientReadReactor<EchoResponse> {
+ public:
+  ReadClient(grpc::testing::EchoTestService::Stub* stub,
+             ServerTryCancelRequestPhase server_try_cancel,
+             ClientCancelInfo client_cancel = {})
+      : server_try_cancel_(server_try_cancel), client_cancel_{client_cancel} {
+    if (server_try_cancel_ != DO_NOT_CANCEL) {
+      // Send server_try_cancel value in the client metadata
+      context_.AddMetadata(kServerTryCancelRequest,
+                           grpc::to_string(server_try_cancel));
     }
-    void OnReadDone(bool ok) override {
-      if (!ok) {
+    request_.set_message("Hello client ");
+    stub->experimental_async()->ResponseStream(&context_, &request_, this);
+    if (client_cancel_.cancel &&
+        reads_complete_ == client_cancel_.ops_before_cancel) {
+      context_.TryCancel();
+    }
+    // Even if we cancel, read until failure because there might be responses
+    // pending
+    StartRead(&response_);
+    StartCall();
+  }
+  void OnReadDone(bool ok) override {
+    if (!ok) {
+      if (server_try_cancel_ == DO_NOT_CANCEL && !client_cancel_.cancel) {
         EXPECT_EQ(reads_complete_, kServerDefaultResponseStreamsToSend);
-      } else {
-        EXPECT_LE(reads_complete_, kServerDefaultResponseStreamsToSend);
-        EXPECT_EQ(response_.message(),
-                  request_.message() + grpc::to_string(reads_complete_));
-        reads_complete_++;
-        StartRead(&response_);
       }
+    } else {
+      EXPECT_LE(reads_complete_, kServerDefaultResponseStreamsToSend);
+      EXPECT_EQ(response_.message(),
+                request_.message() + grpc::to_string(reads_complete_));
+      reads_complete_++;
+      if (client_cancel_.cancel &&
+          reads_complete_ == client_cancel_.ops_before_cancel) {
+        context_.TryCancel();
+      }
+      // Even if we cancel, read until failure because there might be responses
+      // pending
+      StartRead(&response_);
     }
-    void OnDone(const Status& s) override {
-      EXPECT_TRUE(s.ok());
-      std::unique_lock<std::mutex> l(mu_);
-      done_ = true;
-      cv_.notify_one();
+  }
+  void OnDone(const Status& s) override {
+    gpr_log(GPR_INFO, "Read %d messages", reads_complete_);
+    switch (server_try_cancel_) {
+      case DO_NOT_CANCEL:
+        if (!client_cancel_.cancel || client_cancel_.ops_before_cancel >
+                                          kServerDefaultResponseStreamsToSend) {
+          EXPECT_TRUE(s.ok());
+          EXPECT_EQ(reads_complete_, kServerDefaultResponseStreamsToSend);
+        } else {
+          EXPECT_GE(reads_complete_, client_cancel_.ops_before_cancel);
+          EXPECT_LE(reads_complete_, kServerDefaultResponseStreamsToSend);
+          // Status might be ok or cancelled depending on whether server
+          // sent status before client cancel went through
+          if (!s.ok()) {
+            EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+          }
+        }
+        break;
+      case CANCEL_BEFORE_PROCESSING:
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        EXPECT_EQ(reads_complete_, 0);
+        break;
+      case CANCEL_DURING_PROCESSING:
+      case CANCEL_AFTER_PROCESSING:
+        // If server canceled while writing messages, client must have read
+        // less than or equal to the expected number of messages. Even if the
+        // server canceled after writing all messages, the RPC may be canceled
+        // before the Client got a chance to read all the messages.
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        EXPECT_LE(reads_complete_, kServerDefaultResponseStreamsToSend);
+        break;
+      default:
+        assert(false);
     }
-    void Await() {
-      std::unique_lock<std::mutex> l(mu_);
-      while (!done_) {
-        cv_.wait(l);
-      }
+    std::unique_lock<std::mutex> l(mu_);
+    done_ = true;
+    cv_.notify_one();
+  }
+  void Await() {
+    std::unique_lock<std::mutex> l(mu_);
+    while (!done_) {
+      cv_.wait(l);
     }
+  }
 
-   private:
-    EchoRequest request_;
-    EchoResponse response_;
-    ClientContext context_;
-    int reads_complete_{0};
-    std::mutex mu_;
-    std::condition_variable cv_;
-    bool done_ = false;
-  } test{stub_.get()};
+ private:
+  EchoRequest request_;
+  EchoResponse response_;
+  ClientContext context_;
+  const ServerTryCancelRequestPhase server_try_cancel_;
+  int reads_complete_{0};
+  const ClientCancelInfo client_cancel_;
+  std::mutex mu_;
+  std::condition_variable cv_;
+  bool done_ = false;
+};
+
+TEST_P(ClientCallbackEnd2endTest, ResponseStream) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  ReadClient test{stub_.get(), DO_NOT_CANCEL};
+  test.Await();
+  // Make sure that the server interceptors were not notified of a cancel
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(0, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+TEST_P(ClientCallbackEnd2endTest, ClientCancelsResponseStream) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  ReadClient test{stub_.get(), DO_NOT_CANCEL, 2};
+  test.Await();
+  // Because cancel in this case races with server finish, we can't be sure that
+  // server interceptors even see cancellation
+}
+
+// Server to cancel before sending any response messages
+TEST_P(ClientCallbackEnd2endTest, ResponseStreamServerCancelBefore) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  ReadClient test{stub_.get(), CANCEL_BEFORE_PROCESSING};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel while writing a response to the stream in parallel
+TEST_P(ClientCallbackEnd2endTest, ResponseStreamServerCancelDuring) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  ReadClient test{stub_.get(), CANCEL_DURING_PROCESSING};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
 
+// Server to cancel after writing all the respones to the stream but before
+// returning to the client
+TEST_P(ClientCallbackEnd2endTest, ResponseStreamServerCancelAfter) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  ReadClient test{stub_.get(), CANCEL_AFTER_PROCESSING};
   test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
 }
 
+class BidiClient
+    : public grpc::experimental::ClientBidiReactor<EchoRequest, EchoResponse> {
+ public:
+  BidiClient(grpc::testing::EchoTestService::Stub* stub,
+             ServerTryCancelRequestPhase server_try_cancel,
+             int num_msgs_to_send, ClientCancelInfo client_cancel = {})
+      : server_try_cancel_(server_try_cancel),
+        msgs_to_send_{num_msgs_to_send},
+        client_cancel_{client_cancel} {
+    if (server_try_cancel_ != DO_NOT_CANCEL) {
+      // Send server_try_cancel value in the client metadata
+      context_.AddMetadata(kServerTryCancelRequest,
+                           grpc::to_string(server_try_cancel));
+    }
+    request_.set_message("Hello fren ");
+    stub->experimental_async()->BidiStream(&context_, this);
+    MaybeWrite();
+    StartRead(&response_);
+    StartCall();
+  }
+  void OnReadDone(bool ok) override {
+    if (!ok) {
+      if (server_try_cancel_ == DO_NOT_CANCEL) {
+        if (!client_cancel_.cancel) {
+          EXPECT_EQ(reads_complete_, msgs_to_send_);
+        } else {
+          EXPECT_LE(reads_complete_, writes_complete_);
+        }
+      }
+    } else {
+      EXPECT_LE(reads_complete_, msgs_to_send_);
+      EXPECT_EQ(response_.message(), request_.message());
+      reads_complete_++;
+      StartRead(&response_);
+    }
+  }
+  void OnWriteDone(bool ok) override {
+    if (server_try_cancel_ == DO_NOT_CANCEL) {
+      EXPECT_TRUE(ok);
+    } else if (!ok) {
+      return;
+    }
+    writes_complete_++;
+    MaybeWrite();
+  }
+  void OnDone(const Status& s) override {
+    gpr_log(GPR_INFO, "Sent %d messages", writes_complete_);
+    gpr_log(GPR_INFO, "Read %d messages", reads_complete_);
+    switch (server_try_cancel_) {
+      case DO_NOT_CANCEL:
+        if (!client_cancel_.cancel ||
+            client_cancel_.ops_before_cancel > msgs_to_send_) {
+          EXPECT_TRUE(s.ok());
+          EXPECT_EQ(writes_complete_, msgs_to_send_);
+          EXPECT_EQ(reads_complete_, writes_complete_);
+        } else {
+          EXPECT_FALSE(s.ok());
+          EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+          EXPECT_EQ(writes_complete_, client_cancel_.ops_before_cancel);
+          EXPECT_LE(reads_complete_, writes_complete_);
+        }
+        break;
+      case CANCEL_BEFORE_PROCESSING:
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        // The RPC is canceled before the server did any work or returned any
+        // reads, but it's possible that some writes took place first from the
+        // client
+        EXPECT_LE(writes_complete_, msgs_to_send_);
+        EXPECT_EQ(reads_complete_, 0);
+        break;
+      case CANCEL_DURING_PROCESSING:
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        EXPECT_LE(writes_complete_, msgs_to_send_);
+        EXPECT_LE(reads_complete_, writes_complete_);
+        break;
+      case CANCEL_AFTER_PROCESSING:
+        EXPECT_FALSE(s.ok());
+        EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code());
+        EXPECT_EQ(writes_complete_, msgs_to_send_);
+        // The Server canceled after reading the last message and after writing
+        // the message to the client. However, the RPC cancellation might have
+        // taken effect before the client actually read the response.
+        EXPECT_LE(reads_complete_, writes_complete_);
+        break;
+      default:
+        assert(false);
+    }
+    std::unique_lock<std::mutex> l(mu_);
+    done_ = true;
+    cv_.notify_one();
+  }
+  void Await() {
+    std::unique_lock<std::mutex> l(mu_);
+    while (!done_) {
+      cv_.wait(l);
+    }
+  }
+
+ private:
+  void MaybeWrite() {
+    if (client_cancel_.cancel &&
+        writes_complete_ == client_cancel_.ops_before_cancel) {
+      context_.TryCancel();
+    } else if (writes_complete_ == msgs_to_send_) {
+      StartWritesDone();
+    } else {
+      StartWrite(&request_);
+    }
+  }
+  EchoRequest request_;
+  EchoResponse response_;
+  ClientContext context_;
+  const ServerTryCancelRequestPhase server_try_cancel_;
+  int reads_complete_{0};
+  int writes_complete_{0};
+  const int msgs_to_send_;
+  const ClientCancelInfo client_cancel_;
+  std::mutex mu_;
+  std::condition_variable cv_;
+  bool done_ = false;
+};
+
 TEST_P(ClientCallbackEnd2endTest, BidiStream) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  BidiClient test{stub_.get(), DO_NOT_CANCEL,
+                  kServerDefaultResponseStreamsToSend};
+  test.Await();
+  // Make sure that the server interceptors were not notified of a cancel
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(0, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+TEST_P(ClientCallbackEnd2endTest, ClientCancelsBidiStream) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  BidiClient test{stub_.get(), DO_NOT_CANCEL,
+                  kServerDefaultResponseStreamsToSend, 2};
+  test.Await();
+  // Make sure that the server interceptors were notified of a cancel
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel before reading/writing any requests/responses on the stream
+TEST_P(ClientCallbackEnd2endTest, BidiStreamServerCancelBefore) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  BidiClient test{stub_.get(), CANCEL_BEFORE_PROCESSING, 2};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel while reading/writing requests/responses on the stream in
+// parallel
+TEST_P(ClientCallbackEnd2endTest, BidiStreamServerCancelDuring) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  BidiClient test{stub_.get(), CANCEL_DURING_PROCESSING, 10};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+// Server to cancel after reading/writing all requests/responses on the stream
+// but before returning to the client
+TEST_P(ClientCallbackEnd2endTest, BidiStreamServerCancelAfter) {
+  MAYBE_SKIP_TEST;
+  ResetStub();
+  BidiClient test{stub_.get(), CANCEL_AFTER_PROCESSING, 5};
+  test.Await();
+  // Make sure that the server interceptors were notified
+  if (GetParam().use_interceptors) {
+    EXPECT_EQ(20, DummyInterceptor::GetNumTimesCancel());
+  }
+}
+
+TEST_P(ClientCallbackEnd2endTest, SimultaneousReadAndWritesDone) {
   MAYBE_SKIP_TEST;
   ResetStub();
   class Client : public grpc::experimental::ClientBidiReactor<EchoRequest,
                                                               EchoResponse> {
    public:
-    explicit Client(grpc::testing::EchoTestService::Stub* stub) {
-      request_.set_message("Hello fren ");
+    Client(grpc::testing::EchoTestService::Stub* stub) {
+      request_.set_message("Hello bidi ");
       stub->experimental_async()->BidiStream(&context_, this);
-      StartCall();
-      StartRead(&response_);
       StartWrite(&request_);
+      StartCall();
     }
     void OnReadDone(bool ok) override {
-      if (!ok) {
-        EXPECT_EQ(reads_complete_, kServerDefaultResponseStreamsToSend);
-      } else {
-        EXPECT_LE(reads_complete_, kServerDefaultResponseStreamsToSend);
-        EXPECT_EQ(response_.message(), request_.message());
-        reads_complete_++;
-        StartRead(&response_);
-      }
+      EXPECT_TRUE(ok);
+      EXPECT_EQ(response_.message(), request_.message());
     }
     void OnWriteDone(bool ok) override {
       EXPECT_TRUE(ok);
-      if (++writes_complete_ == kServerDefaultResponseStreamsToSend) {
-        StartWritesDone();
-      } else {
-        StartWrite(&request_);
-      }
+      // Now send out the simultaneous Read and WritesDone
+      StartWritesDone();
+      StartRead(&response_);
     }
     void OnDone(const Status& s) override {
       EXPECT_TRUE(s.ok());
+      EXPECT_EQ(response_.message(), request_.message());
       std::unique_lock<std::mutex> l(mu_);
       done_ = true;
       cv_.notify_one();
@@ -564,8 +1040,6 @@ TEST_P(ClientCallbackEnd2endTest, BidiStream) {
     EchoRequest request_;
     EchoResponse response_;
     ClientContext context_;
-    int reads_complete_{0};
-    int writes_complete_{0};
     std::mutex mu_;
     std::condition_variable cv_;
     bool done_ = false;
@@ -574,13 +1048,42 @@ TEST_P(ClientCallbackEnd2endTest, BidiStream) {
   test.Await();
 }
 
-TestScenario scenarios[]{{false, Protocol::INPROC},
-                         {false, Protocol::TCP},
-                         {true, Protocol::INPROC},
-                         {true, Protocol::TCP}};
+std::vector<TestScenario> CreateTestScenarios(bool test_insecure) {
+  std::vector<TestScenario> scenarios;
+  std::vector<grpc::string> credentials_types{
+      GetCredentialsProvider()->GetSecureCredentialsTypeList()};
+  auto insec_ok = [] {
+    // Only allow insecure credentials type when it is registered with the
+    // provider. User may create providers that do not have insecure.
+    return GetCredentialsProvider()->GetChannelCredentials(
+               kInsecureCredentialsType, nullptr) != nullptr;
+  };
+  if (test_insecure && insec_ok()) {
+    credentials_types.push_back(kInsecureCredentialsType);
+  }
+  GPR_ASSERT(!credentials_types.empty());
+
+  bool barr[]{false, true};
+  Protocol parr[]{Protocol::INPROC, Protocol::TCP};
+  for (Protocol p : parr) {
+    for (const auto& cred : credentials_types) {
+      // TODO(vjpai): Test inproc with secure credentials when feasible
+      if (p == Protocol::INPROC &&
+          (cred != kInsecureCredentialsType || !insec_ok())) {
+        continue;
+      }
+      for (bool callback_server : barr) {
+        for (bool use_interceptors : barr) {
+          scenarios.emplace_back(callback_server, p, use_interceptors, cred);
+        }
+      }
+    }
+  }
+  return scenarios;
+}
 
 INSTANTIATE_TEST_CASE_P(ClientCallbackEnd2endTest, ClientCallbackEnd2endTest,
-                        ::testing::ValuesIn(scenarios));
+                        ::testing::ValuesIn(CreateTestScenarios(true)));
 
 }  // namespace
 }  // namespace testing

test/cpp/end2end/client_lb_end2end_test.cc

@@ -402,6 +402,27 @@ class ClientLbEnd2endTest : public ::testing::Test {
   std::shared_ptr<ChannelCredentials> creds_;
 };
 
+TEST_F(ClientLbEnd2endTest, ChannelStateConnectingWhenResolving) {
+  const int kNumServers = 3;
+  StartServers(kNumServers);
+  auto channel = BuildChannel("");
+  auto stub = BuildStub(channel);
+  // Initial state should be IDLE.
+  EXPECT_EQ(channel->GetState(false /* try_to_connect */), GRPC_CHANNEL_IDLE);
+  // Tell the channel to try to connect.
+  // Note that this call also returns IDLE, since the state change has
+  // not yet occurred; it just gets triggered by this call.
+  EXPECT_EQ(channel->GetState(true /* try_to_connect */), GRPC_CHANNEL_IDLE);
+  // Now that the channel is trying to connect, we should be in state
+  // CONNECTING.
+  EXPECT_EQ(channel->GetState(false /* try_to_connect */),
+            GRPC_CHANNEL_CONNECTING);
+  // Return a resolver result, which allows the connection attempt to proceed.
+  SetNextResolution(GetServersPorts());
+  // We should eventually transition into state READY.
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+}
+
 TEST_F(ClientLbEnd2endTest, PickFirst) {
   // Start servers and send one RPC per server.
   const int kNumServers = 3;

test/cpp/end2end/flaky_network_test.cc

@@ -0,0 +1,492 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <random>
+#include <thread>
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/health_check_service_interface.h>
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/gpr/env.h"
+
+#include "src/proto/grpc/testing/echo.grpc.pb.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+#include "test/cpp/end2end/test_service_impl.h"
+
+#include <gtest/gtest.h>
+
+#ifdef GPR_LINUX
+using grpc::testing::EchoRequest;
+using grpc::testing::EchoResponse;
+
+namespace grpc {
+namespace testing {
+namespace {
+
+class FlakyNetworkTest : public ::testing::Test {
+ protected:
+  FlakyNetworkTest()
+      : server_host_("grpctest"),
+        interface_("lo:1"),
+        ipv4_address_("10.0.0.1"),
+        netmask_("/32"),
+        kRequestMessage_("🖖") {}
+
+  void InterfaceUp() {
+    std::ostringstream cmd;
+    // create interface_ with address ipv4_address_
+    cmd << "ip addr add " << ipv4_address_ << netmask_ << " dev " << interface_;
+    std::system(cmd.str().c_str());
+  }
+
+  void InterfaceDown() {
+    std::ostringstream cmd;
+    // remove interface_
+    cmd << "ip addr del " << ipv4_address_ << netmask_ << " dev " << interface_;
+    std::system(cmd.str().c_str());
+  }
+
+  void DNSUp() {
+    std::ostringstream cmd;
+    // Add DNS entry for server_host_ in /etc/hosts
+    cmd << "echo '" << ipv4_address_ << "      " << server_host_
+        << "' >> /etc/hosts";
+    std::system(cmd.str().c_str());
+  }
+
+  void DNSDown() {
+    std::ostringstream cmd;
+    // Remove DNS entry for server_host_ from /etc/hosts
+    // NOTE: we can't do this in one step with sed -i because when we are
+    // running under docker, the file is mounted by docker so we can't change
+    // its inode from within the container (sed -i creates a new file and
+    // replaces the old file, which changes the inode)
+    cmd << "sed  '/" << server_host_ << "/d' /etc/hosts > /etc/hosts.orig";
+    std::system(cmd.str().c_str());
+
+    // clear the stream
+    cmd.str("");
+
+    cmd << "cat /etc/hosts.orig > /etc/hosts";
+    std::system(cmd.str().c_str());
+  }
+
+  void DropPackets() {
+    std::ostringstream cmd;
+    // drop packets with src IP = ipv4_address_
+    cmd << "iptables -A INPUT -s " << ipv4_address_ << " -j DROP";
+
+    std::system(cmd.str().c_str());
+    // clear the stream
+    cmd.str("");
+
+    // drop packets with dst IP = ipv4_address_
+    cmd << "iptables -A INPUT -d " << ipv4_address_ << " -j DROP";
+  }
+
+  void RestoreNetwork() {
+    std::ostringstream cmd;
+    // remove iptables rule to drop packets with src IP = ipv4_address_
+    cmd << "iptables -D INPUT -s " << ipv4_address_ << " -j DROP";
+    std::system(cmd.str().c_str());
+    // clear the stream
+    cmd.str("");
+    // remove iptables rule to drop packets with dest IP = ipv4_address_
+    cmd << "iptables -D INPUT -d " << ipv4_address_ << " -j DROP";
+  }
+
+  void FlakeNetwork() {
+    std::ostringstream cmd;
+    // Emulate a flaky network connection over interface_. Add a delay of 100ms
+    // +/- 590ms, 3% packet loss, 1% duplicates and 0.1% corrupt packets.
+    cmd << "tc qdisc replace dev " << interface_
+        << " root netem delay 100ms 50ms distribution normal loss 3% duplicate "
+           "1% corrupt 0.1% ";
+    std::system(cmd.str().c_str());
+  }
+
+  void UnflakeNetwork() {
+    // Remove simulated network flake on interface_
+    std::ostringstream cmd;
+    cmd << "tc qdisc del dev " << interface_ << " root netem";
+    std::system(cmd.str().c_str());
+  }
+
+  void NetworkUp() {
+    InterfaceUp();
+    DNSUp();
+  }
+
+  void NetworkDown() {
+    InterfaceDown();
+    DNSDown();
+  }
+
+  void SetUp() override {
+    NetworkUp();
+    grpc_init();
+    StartServer();
+  }
+
+  void TearDown() override {
+    NetworkDown();
+    StopServer();
+    grpc_shutdown();
+  }
+
+  void StartServer() {
+    // TODO (pjaikumar): Ideally, we should allocate the port dynamically using
+    // grpc_pick_unused_port_or_die(). That doesn't work inside some docker
+    // containers because port_server listens on localhost which maps to
+    // ip6-looopback, but ipv6 support is not enabled by default in docker.
+    port_ = SERVER_PORT;
+
+    server_.reset(new ServerData(port_));
+    server_->Start(server_host_);
+  }
+  void StopServer() { server_->Shutdown(); }
+
+  std::unique_ptr<grpc::testing::EchoTestService::Stub> BuildStub(
+      const std::shared_ptr<Channel>& channel) {
+    return grpc::testing::EchoTestService::NewStub(channel);
+  }
+
+  std::shared_ptr<Channel> BuildChannel(
+      const grpc::string& lb_policy_name,
+      ChannelArguments args = ChannelArguments()) {
+    if (lb_policy_name.size() > 0) {
+      args.SetLoadBalancingPolicyName(lb_policy_name);
+    }  // else, default to pick first
+    std::ostringstream server_address;
+    server_address << server_host_ << ":" << port_;
+    return CreateCustomChannel(server_address.str(),
+                               InsecureChannelCredentials(), args);
+  }
+
+  bool SendRpc(
+      const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub,
+      int timeout_ms = 0, bool wait_for_ready = false) {
+    auto response = std::unique_ptr<EchoResponse>(new EchoResponse());
+    EchoRequest request;
+    request.set_message(kRequestMessage_);
+    ClientContext context;
+    if (timeout_ms > 0) {
+      context.set_deadline(grpc_timeout_milliseconds_to_deadline(timeout_ms));
+    }
+    // See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md for
+    // details of wait-for-ready semantics
+    if (wait_for_ready) {
+      context.set_wait_for_ready(true);
+    }
+    Status status = stub->Echo(&context, request, response.get());
+    auto ok = status.ok();
+    if (ok) {
+      gpr_log(GPR_DEBUG, "RPC returned %s\n", response->message().c_str());
+    } else {
+      gpr_log(GPR_DEBUG, "RPC failed: %s", status.error_message().c_str());
+    }
+    return ok;
+  }
+
+  struct ServerData {
+    int port_;
+    std::unique_ptr<Server> server_;
+    TestServiceImpl service_;
+    std::unique_ptr<std::thread> thread_;
+    bool server_ready_ = false;
+
+    explicit ServerData(int port) { port_ = port; }
+
+    void Start(const grpc::string& server_host) {
+      gpr_log(GPR_INFO, "starting server on port %d", port_);
+      std::mutex mu;
+      std::unique_lock<std::mutex> lock(mu);
+      std::condition_variable cond;
+      thread_.reset(new std::thread(
+          std::bind(&ServerData::Serve, this, server_host, &mu, &cond)));
+      cond.wait(lock, [this] { return server_ready_; });
+      server_ready_ = false;
+      gpr_log(GPR_INFO, "server startup complete");
+    }
+
+    void Serve(const grpc::string& server_host, std::mutex* mu,
+               std::condition_variable* cond) {
+      std::ostringstream server_address;
+      server_address << server_host << ":" << port_;
+      ServerBuilder builder;
+      builder.AddListeningPort(server_address.str(),
+                               InsecureServerCredentials());
+      builder.RegisterService(&service_);
+      server_ = builder.BuildAndStart();
+      std::lock_guard<std::mutex> lock(*mu);
+      server_ready_ = true;
+      cond->notify_one();
+    }
+
+    void Shutdown() {
+      server_->Shutdown(grpc_timeout_milliseconds_to_deadline(0));
+      thread_->join();
+    }
+  };
+
+  bool WaitForChannelNotReady(Channel* channel, int timeout_seconds = 5) {
+    const gpr_timespec deadline =
+        grpc_timeout_seconds_to_deadline(timeout_seconds);
+    grpc_connectivity_state state;
+    while ((state = channel->GetState(false /* try_to_connect */)) ==
+           GRPC_CHANNEL_READY) {
+      if (!channel->WaitForStateChange(state, deadline)) return false;
+    }
+    return true;
+  }
+
+  bool WaitForChannelReady(Channel* channel, int timeout_seconds = 5) {
+    const gpr_timespec deadline =
+        grpc_timeout_seconds_to_deadline(timeout_seconds);
+    grpc_connectivity_state state;
+    while ((state = channel->GetState(true /* try_to_connect */)) !=
+           GRPC_CHANNEL_READY) {
+      if (!channel->WaitForStateChange(state, deadline)) return false;
+    }
+    return true;
+  }
+
+ private:
+  const grpc::string server_host_;
+  const grpc::string interface_;
+  const grpc::string ipv4_address_;
+  const grpc::string netmask_;
+  std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
+  std::unique_ptr<ServerData> server_;
+  const int SERVER_PORT = 32750;
+  int port_;
+  const grpc::string kRequestMessage_;
+};
+
+// Network interface connected to server flaps
+TEST_F(FlakyNetworkTest, NetworkTransition) {
+  const int kKeepAliveTimeMs = 1000;
+  const int kKeepAliveTimeoutMs = 1000;
+  ChannelArguments args;
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKeepAliveTimeMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKeepAliveTimeoutMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);
+  args.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, 0);
+
+  auto channel = BuildChannel("pick_first", args);
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  std::atomic_bool shutdown{false};
+  std::thread sender = std::thread([this, &stub, &shutdown]() {
+    while (true) {
+      if (shutdown.load()) {
+        return;
+      }
+      SendRpc(stub);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+  });
+
+  // bring down network
+  NetworkDown();
+  EXPECT_TRUE(WaitForChannelNotReady(channel.get()));
+  // bring network interface back up
+  InterfaceUp();
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  // Restore DNS entry for server
+  DNSUp();
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+  shutdown.store(true);
+  sender.join();
+}
+
+// Traffic to server server is blackholed temporarily with keepalives enabled
+TEST_F(FlakyNetworkTest, ServerUnreachableWithKeepalive) {
+  const int kKeepAliveTimeMs = 1000;
+  const int kKeepAliveTimeoutMs = 1000;
+  ChannelArguments args;
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKeepAliveTimeMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKeepAliveTimeoutMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);
+  args.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, 0);
+
+  auto channel = BuildChannel("pick_first", args);
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  std::atomic_bool shutdown{false};
+  std::thread sender = std::thread([this, &stub, &shutdown]() {
+    while (true) {
+      if (shutdown.load()) {
+        return;
+      }
+      SendRpc(stub);
+      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    }
+  });
+
+  // break network connectivity
+  DropPackets();
+  std::this_thread::sleep_for(std::chrono::milliseconds(10000));
+  EXPECT_TRUE(WaitForChannelNotReady(channel.get()));
+  // bring network interface back up
+  RestoreNetwork();
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+  shutdown.store(true);
+  sender.join();
+}
+
+//
+// Traffic to server server is blackholed temporarily with keepalives disabled
+TEST_F(FlakyNetworkTest, ServerUnreachableNoKeepalive) {
+  auto channel = BuildChannel("pick_first", ChannelArguments());
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  // break network connectivity
+  DropPackets();
+
+  std::thread sender = std::thread([this, &stub]() {
+    // RPC with deadline should timeout
+    EXPECT_FALSE(SendRpc(stub, /*timeout_ms=*/500, /*wait_for_ready=*/true));
+    // RPC without deadline forever until call finishes
+    EXPECT_TRUE(SendRpc(stub, /*timeout_ms=*/0, /*wait_for_ready=*/true));
+  });
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+  // bring network interface back up
+  RestoreNetwork();
+
+  // wait for RPC to finish
+  sender.join();
+}
+
+// Send RPCs over a flaky network connection
+TEST_F(FlakyNetworkTest, FlakyNetwork) {
+  const int kKeepAliveTimeMs = 1000;
+  const int kKeepAliveTimeoutMs = 1000;
+  const int kMessageCount = 100;
+  ChannelArguments args;
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKeepAliveTimeMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKeepAliveTimeoutMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);
+  args.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, 0);
+
+  auto channel = BuildChannel("pick_first", args);
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  // simulate flaky network (packet loss, corruption and delays)
+  FlakeNetwork();
+  for (int i = 0; i < kMessageCount; ++i) {
+    EXPECT_TRUE(SendRpc(stub));
+  }
+  // remove network flakiness
+  UnflakeNetwork();
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+}
+
+// Server is shutdown gracefully and restarted. Client keepalives are enabled
+TEST_F(FlakyNetworkTest, ServerRestartKeepaliveEnabled) {
+  const int kKeepAliveTimeMs = 1000;
+  const int kKeepAliveTimeoutMs = 1000;
+  ChannelArguments args;
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIME_MS, kKeepAliveTimeMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, kKeepAliveTimeoutMs);
+  args.SetInt(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);
+  args.SetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, 0);
+
+  auto channel = BuildChannel("pick_first", args);
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  // server goes down, client should detect server going down and calls should
+  // fail
+  StopServer();
+  EXPECT_TRUE(WaitForChannelNotReady(channel.get()));
+  EXPECT_FALSE(SendRpc(stub));
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+  // server restarts, calls succeed
+  StartServer();
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+  // EXPECT_TRUE(SendRpc(stub));
+}
+
+// Server is shutdown gracefully and restarted. Client keepalives are enabled
+TEST_F(FlakyNetworkTest, ServerRestartKeepaliveDisabled) {
+  auto channel = BuildChannel("pick_first", ChannelArguments());
+  auto stub = BuildStub(channel);
+  // Channel should be in READY state after we send an RPC
+  EXPECT_TRUE(SendRpc(stub));
+  EXPECT_EQ(channel->GetState(false), GRPC_CHANNEL_READY);
+
+  // server sends GOAWAY when it's shutdown, so client attempts to reconnect
+  StopServer();
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+  EXPECT_TRUE(WaitForChannelNotReady(channel.get()));
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+  // server restarts, calls succeed
+  StartServer();
+  EXPECT_TRUE(WaitForChannelReady(channel.get()));
+}
+
+}  // namespace
+}  // namespace testing
+}  // namespace grpc
+#endif  // GPR_LINUX
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  grpc_test_init(argc, argv);
+  auto result = RUN_ALL_TESTS();
+  return result;
+}

test/cpp/end2end/test_service_impl.cc

@@ -583,7 +583,10 @@ CallbackTestServiceImpl::RequestStream() {
       StartRead(&request_);
     }
     void OnDone() override { delete this; }
-    void OnCancel() override { FinishOnce(Status::CANCELLED); }
+    void OnCancel() override {
+      EXPECT_TRUE(ctx_->IsCancelled());
+      FinishOnce(Status::CANCELLED);
+    }
     void OnReadDone(bool ok) override {
       if (ok) {
         response_->mutable_message()->append(request_.message());
@@ -666,7 +669,10 @@ CallbackTestServiceImpl::ResponseStream() {
       }
     }
     void OnDone() override { delete this; }
-    void OnCancel() override { FinishOnce(Status::CANCELLED); }
+    void OnCancel() override {
+      EXPECT_TRUE(ctx_->IsCancelled());
+      FinishOnce(Status::CANCELLED);
+    }
     void OnWriteDone(bool ok) override {
       if (num_msgs_sent_ < server_responses_to_send_) {
         NextWrite();
@@ -749,7 +755,10 @@ CallbackTestServiceImpl::BidiStream() {
       StartRead(&request_);
     }
     void OnDone() override { delete this; }
-    void OnCancel() override { FinishOnce(Status::CANCELLED); }
+    void OnCancel() override {
+      EXPECT_TRUE(ctx_->IsCancelled());
+      FinishOnce(Status::CANCELLED);
+    }
     void OnReadDone(bool ok) override {
       if (ok) {
         num_msgs_read_++;

test/cpp/microbenchmarks/bm_call_create.cc

@@ -570,6 +570,7 @@ static void BM_IsolatedFilter(benchmark::State& state) {
   }
   gpr_arena_destroy(call_args.arena);
   grpc_channel_stack_destroy(channel_stack);
+  grpc_core::ExecCtx::Get()->Flush();
 
   gpr_free(channel_stack);
   gpr_free(call_stack);

test/cpp/qps/client_callback.cc

@@ -253,18 +253,20 @@ class CallbackStreamingPingPongReactor final
       : client_(client), ctx_(std::move(ctx)), messages_issued_(0) {}
 
   void StartNewRpc() {
-    if (client_->ThreadCompleted()) return;
     ctx_->stub_->experimental_async()->StreamingCall(&(ctx_->context_), this);
     write_time_ = UsageTimer::Now();
     StartWrite(client_->request());
+    writes_done_started_.clear();
     StartCall();
   }
 
   void OnWriteDone(bool ok) override {
-    if (!ok || client_->ThreadCompleted()) {
-      if (!ok) gpr_log(GPR_ERROR, "Error writing RPC");
+    if (!ok) {
+      gpr_log(GPR_ERROR, "Error writing RPC");
+    }
+    if ((!ok || client_->ThreadCompleted()) &&
+        !writes_done_started_.test_and_set()) {
       StartWritesDone();
-      return;
     }
     StartRead(&ctx_->response_);
   }
@@ -278,7 +280,9 @@ class CallbackStreamingPingPongReactor final
       if (!ok) {
         gpr_log(GPR_ERROR, "Error reading RPC");
       }
-      StartWritesDone();
+      if (!writes_done_started_.test_and_set()) {
+        StartWritesDone();
+      }
       return;
     }
     write_time_ = UsageTimer::Now();
@@ -295,8 +299,6 @@ class CallbackStreamingPingPongReactor final
   }
 
   void ScheduleRpc() {
-    if (client_->ThreadCompleted()) return;
-
     if (!client_->IsClosedLoop()) {
       gpr_timespec next_issue_time = client_->NextRPCIssueTime();
       // Start an alarm callback to run the internal callback after
@@ -312,6 +314,7 @@ class CallbackStreamingPingPongReactor final
 
   CallbackStreamingPingPongClient* client_;
   std::unique_ptr<CallbackClientRpcContext> ctx_;
+  std::atomic_flag writes_done_started_;
   Client::Thread* thread_ptr_;  // Needed to update histogram entries
   double write_time_;           // Track ping-pong round start time
   int messages_issued_;         // Messages issued by this stream

third_party/cares/cares.BUILD

@@ -3,6 +3,11 @@ config_setting(
     values = {"cpu": "darwin"},
 )
 
+config_setting(
+    name = "darwin_x86_64",
+    values = {"cpu": "darwin_x86_64"},
+)
+
 config_setting(
     name = "windows",
     values = {"cpu": "x64_windows"},
@@ -54,6 +59,7 @@ genrule(
         ":ios_armv7s": ["@com_github_grpc_grpc//third_party/cares:config_darwin/ares_config.h"],
         ":ios_arm64": ["@com_github_grpc_grpc//third_party/cares:config_darwin/ares_config.h"],
         ":darwin": ["@com_github_grpc_grpc//third_party/cares:config_darwin/ares_config.h"],
+        ":darwin_x86_64": ["@com_github_grpc_grpc//third_party/cares:config_darwin/ares_config.h"],
         ":windows": ["@com_github_grpc_grpc//third_party/cares:config_windows/ares_config.h"],
         ":android": ["@com_github_grpc_grpc//third_party/cares:config_android/ares_config.h"],
         "//conditions:default": ["@com_github_grpc_grpc//third_party/cares:config_linux/ares_config.h"],

tools/doxygen/Doxyfile.c++.internal

@@ -1068,8 +1068,6 @@ src/core/lib/gpr/tmpfile.h \
 src/core/lib/gpr/useful.h \
 src/core/lib/gprpp/abstract.h \
 src/core/lib/gprpp/atomic.h \
-src/core/lib/gprpp/atomic_with_atm.h \
-src/core/lib/gprpp/atomic_with_std.h \
 src/core/lib/gprpp/debug_location.h \
 src/core/lib/gprpp/fork.h \
 src/core/lib/gprpp/inlined_vector.h \

tools/doxygen/Doxyfile.core.internal

@@ -936,8 +936,6 @@ src/core/ext/filters/client_channel/proxy_mapper.cc \
 src/core/ext/filters/client_channel/proxy_mapper.h \
 src/core/ext/filters/client_channel/proxy_mapper_registry.cc \
 src/core/ext/filters/client_channel/proxy_mapper_registry.h \
-src/core/ext/filters/client_channel/request_routing.cc \
-src/core/ext/filters/client_channel/request_routing.h \
 src/core/ext/filters/client_channel/resolver.cc \
 src/core/ext/filters/client_channel/resolver.h \
 src/core/ext/filters/client_channel/resolver/README.md \
@@ -962,6 +960,8 @@ src/core/ext/filters/client_channel/resolver_registry.cc \
 src/core/ext/filters/client_channel/resolver_registry.h \
 src/core/ext/filters/client_channel/resolver_result_parsing.cc \
 src/core/ext/filters/client_channel/resolver_result_parsing.h \
+src/core/ext/filters/client_channel/resolving_lb_policy.cc \
+src/core/ext/filters/client_channel/resolving_lb_policy.h \
 src/core/ext/filters/client_channel/retry_throttle.cc \
 src/core/ext/filters/client_channel/retry_throttle.h \
 src/core/ext/filters/client_channel/server_address.cc \
@@ -1157,8 +1157,6 @@ src/core/lib/gpr/wrap_memcpy.cc \
 src/core/lib/gprpp/README.md \
 src/core/lib/gprpp/abstract.h \
 src/core/lib/gprpp/atomic.h \
-src/core/lib/gprpp/atomic_with_atm.h \
-src/core/lib/gprpp/atomic_with_std.h \
 src/core/lib/gprpp/debug_location.h \
 src/core/lib/gprpp/fork.cc \
 src/core/lib/gprpp/fork.h \

tools/http2_interop/doc.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 // http2interop project doc.go
 
 /*

tools/http2_interop/frame.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http2interop
 
 import (

tools/http2_interop/frameheader.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http2interop
 
 import (

tools/http2_interop/goaway.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http2interop
 
 import (

tools/http2_interop/http1frame.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http2interop
 
 import (

tools/http2_interop/http2interop.go

@@ -1,3 +1,17 @@
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 package http2interop
 
 import (