Merge branch 'master' of https://github.com/grpc/grpc into channelz

.clang-tidy

@@ -1,6 +1,6 @@
 ---
-Checks: 'modernize-use-nullptr,google-build-namespaces,google-build-explicit-make-pair,readability-function-size'
-WarningsAsErrors: 'modernize-use-nullptr,google-build-namespaces,google-build-explicit-make-pair,readability-function-size'
+Checks: 'modernize-use-nullptr,google-build-namespaces,google-build-explicit-make-pair,readability-function-size,performance-*'
+WarningsAsErrors: 'modernize-use-nullptr,google-build-namespaces,google-build-explicit-make-pair,readability-function-size,performance-*'
 CheckOptions:
   - key:    readability-function-size.StatementThreshold
     value:  '450'

BUILD

@@ -64,11 +64,11 @@ config_setting(
 )
 
 # This should be updated along with build.yaml
-g_stands_for = "gloriosa"
+g_stands_for = "gladiolus"
 
 core_version = "6.0.0-dev"
 
-version = "1.13.0-dev"
+version = "1.14.0-dev"
 
 GPR_PUBLIC_HDRS = [
     "include/grpc/support/alloc.h",

Makefile

@@ -334,12 +334,10 @@ CXXFLAGS += -std=c++11
 ifeq ($(SYSTEM),Darwin)
 CXXFLAGS += -stdlib=libc++
 endif
-CPPFLAGS += -g -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter -DOSATOMIC_USE_INLINED=1 -Wno-deprecated-declarations
+CPPFLAGS += -g -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter -DOSATOMIC_USE_INLINED=1 -Wno-deprecated-declarations -Ithird_party/nanopb -DPB_FIELD_32BIT
 COREFLAGS += -fno-rtti -fno-exceptions
 LDFLAGS += -g
 
-DEFINES += PB_FIELD_16BIT
-
 CPPFLAGS += $(CPPFLAGS_$(CONFIG))
 CFLAGS += $(CFLAGS_$(CONFIG))
 CXXFLAGS += $(CXXFLAGS_$(CONFIG))
@@ -421,8 +419,8 @@ Q = @
 endif
 
 CORE_VERSION = 6.0.0-dev
-CPP_VERSION = 1.13.0-dev
-CSHARP_VERSION = 1.13.0-dev
+CPP_VERSION = 1.14.0-dev
+CSHARP_VERSION = 1.14.0-dev
 
 CPPFLAGS_NO_ARCH += $(addprefix -I, $(INCLUDES)) $(addprefix -D, $(DEFINES))
 CPPFLAGS += $(CPPFLAGS_NO_ARCH) $(ARCH_FLAGS)

bazel/grpc_build_system.bzl

@@ -36,9 +36,7 @@ def if_not_windows(a):
 def _get_external_deps(external_deps):
   ret = []
   for dep in external_deps:
-    if dep == "nanopb":
-      ret += ["grpc_nanopb"]
-    elif dep == "address_sorting":
+    if dep == "address_sorting":
       ret += ["//third_party/address_sorting"]
     elif dep == "cares":
       ret += select({"//:grpc_no_ares": [],
@@ -62,7 +60,7 @@ def _maybe_update_cc_library_hdrs(hdrs):
 def grpc_cc_library(name, srcs = [], public_hdrs = [], hdrs = [],
                     external_deps = [], deps = [], standalone = False,
                     language = "C++", testonly = False, visibility = None,
-                    alwayslink = 0, data = []):
+                    alwayslink = 0):
   copts = []
   if language.upper() == "C":
     copts = if_not_windows(["-std=c99"])
@@ -87,7 +85,6 @@ def grpc_cc_library(name, srcs = [], public_hdrs = [], hdrs = [],
         "include"
     ],
     alwayslink = alwayslink,
-    data = data,
   )
 
 def grpc_proto_plugin(name, srcs = [], deps = []):
@@ -162,24 +159,7 @@ def grpc_cc_binary(name, srcs = [], deps = [], external_deps = [], args = [], da
     linkopts = if_not_windows(["-pthread"]) + linkopts,
   )
 
-def grpc_generate_one_off_targets():
-  native.cc_library(
-    name = "grpc_nanopb",
-    hdrs = [
-      "//third_party/nanopb:pb.h",
-      "//third_party/nanopb:pb_common.h",
-      "//third_party/nanopb:pb_decode.h",
-      "//third_party/nanopb:pb_encode.h",
-    ],
-    srcs = [
-      "//third_party/nanopb:pb_common.c",
-      "//third_party/nanopb:pb_decode.c",
-      "//third_party/nanopb:pb_encode.c",
-    ],
-    defines = [
-      "PB_FIELD_16BIT=1",
-    ],
-  )
+def grpc_generate_one_off_targets(): pass
 
 def grpc_sh_test(name, srcs, args = [], data = []):
   native.sh_test(

bazel/grpc_deps.bzl

@@ -2,6 +2,12 @@
 
 def grpc_deps():
     """Loads dependencies need to compile and test the grpc library."""
+
+    native.bind(
+        name = "nanopb",
+        actual = "@com_github_nanopb_nanopb//:nanopb",
+    )
+
     native.bind(
         name = "libssl",
         actual = "@boringssl//:ssl",
@@ -59,12 +65,12 @@ def grpc_deps():
 
     native.bind(
         name = "grpc_cpp_plugin",
-        actual = "@com_github_grpc_grpc//:grpc_cpp_plugin"
+        actual = "@com_github_grpc_grpc//:grpc_cpp_plugin",
     )
 
     native.bind(
         name = "grpc++_codegen_proto",
-        actual = "@com_github_grpc_grpc//:grpc++_codegen_proto"
+        actual = "@com_github_grpc_grpc//:grpc++_codegen_proto",
     )
 
     if "boringssl" not in native.existing_rules():
@@ -87,6 +93,14 @@ def grpc_deps():
             name = "com_google_protobuf",
             strip_prefix = "protobuf-b5fbb742af122b565925987e65c08957739976a7",
             url = "https://github.com/google/protobuf/archive/b5fbb742af122b565925987e65c08957739976a7.tar.gz",
+            )
+
+    if "com_github_nanopb_nanopb" not in native.existing_rules():
+        native.new_http_archive(
+            name = "com_github_nanopb_nanopb",
+            build_file = "@com_github_grpc_grpc//third_party:nanopb.BUILD",
+            strip_prefix = "nanopb-f8ac463766281625ad710900479130c7fcb4d63b",
+            url = "https://github.com/nanopb/nanopb/archive/f8ac463766281625ad710900479130c7fcb4d63b.tar.gz",
         )
 
     if "com_github_google_googletest" not in native.existing_rules():

build.yaml

@@ -13,8 +13,8 @@ settings:
   '#09': Per-language overrides are possible with (eg) ruby_version tag here
   '#10': See the expand_version.py for all the quirks here
   core_version: 6.0.0-dev
-  g_stands_for: gloriosa
-  version: 1.13.0-dev
+  g_stands_for: gladiolus
+  version: 1.14.0-dev
 filegroups:
 - name: alts_proto
   headers:
@@ -5644,7 +5644,7 @@ defaults:
   global:
     COREFLAGS: -fno-rtti -fno-exceptions
     CPPFLAGS: -g -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter -DOSATOMIC_USE_INLINED=1
-      -Wno-deprecated-declarations
+      -Wno-deprecated-declarations -Ithird_party/nanopb -DPB_FIELD_32BIT
     LDFLAGS: -g
   zlib:
     CFLAGS: -Wno-sign-conversion -Wno-conversion -Wno-unused-value -Wno-implicit-function-declaration

tools/BUILD → cmake/nanopb.cmake

@@ -1,4 +1,4 @@
-# Copyright 2017 gRPC authors.
+# 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.
@@ -12,8 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-exports_files([
-    "lsan_suppressions.txt",
-    "tsan_suppressions.txt",
-    "ubsan_suppressions.txt",
-])
+set(_gRPC_NANOPB_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/nanopb")

doc/g_stands_for.md

@@ -12,4 +12,5 @@
 - 1.10 'g' stands for ['glamorous'](https://github.com/grpc/grpc/tree/v1.10.x)
 - 1.11 'g' stands for ['gorgeous'](https://github.com/grpc/grpc/tree/v1.11.x)
 - 1.12 'g' stands for ['glorious'](https://github.com/grpc/grpc/tree/v1.12.x)
-- 1.13 'g' stands for ['gloriosa'](https://github.com/grpc/grpc/tree/master)
+- 1.13 'g' stands for ['gloriosa'](https://github.com/grpc/grpc/tree/v1.13.x)
+- 1.14 'g' stands for ['gladiolus'](https://github.com/grpc/grpc/tree/master)

examples/python/helloworld/greeter_client.py

@@ -22,9 +22,12 @@ import helloworld_pb2_grpc
 
 
 def run():
-    channel = grpc.insecure_channel('localhost:50051')
-    stub = helloworld_pb2_grpc.GreeterStub(channel)
-    response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
+    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
+    # used in circumstances in which the with statement does not fit the needs
+    # of the code.
+    with grpc.insecure_channel('localhost:50051') as channel:
+        stub = helloworld_pb2_grpc.GreeterStub(channel)
+        response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
     print("Greeter client received: " + response.message)
 
 

examples/python/interceptors/default_value/greeter_client.py

@@ -27,10 +27,14 @@ def run():
         message='Hello from your local interceptor!')
     default_value_interceptor = default_value_client_interceptor.DefaultValueClientInterceptor(
         default_value)
-    channel = grpc.insecure_channel('localhost:50051')
-    channel = grpc.intercept_channel(channel, default_value_interceptor)
-    stub = helloworld_pb2_grpc.GreeterStub(channel)
-    response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
+    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
+    # used in circumstances in which the with statement does not fit the needs
+    # of the code.
+    with grpc.insecure_channel('localhost:50051') as channel:
+        intercept_channel = grpc.intercept_channel(channel,
+                                                   default_value_interceptor)
+        stub = helloworld_pb2_grpc.GreeterStub(intercept_channel)
+        response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
     print("Greeter client received: " + response.message)
 
 

examples/python/interceptors/headers/greeter_client.py

@@ -25,10 +25,14 @@ import header_manipulator_client_interceptor
 def run():
     header_adder_interceptor = header_manipulator_client_interceptor.header_adder_interceptor(
         'one-time-password', '42')
-    channel = grpc.insecure_channel('localhost:50051')
-    channel = grpc.intercept_channel(channel, header_adder_interceptor)
-    stub = helloworld_pb2_grpc.GreeterStub(channel)
-    response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
+    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
+    # used in circumstances in which the with statement does not fit the needs
+    # of the code.
+    with grpc.insecure_channel('localhost:50051') as channel:
+        intercept_channel = grpc.intercept_channel(channel,
+                                                   header_adder_interceptor)
+        stub = helloworld_pb2_grpc.GreeterStub(intercept_channel)
+        response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'))
     print("Greeter client received: " + response.message)
 
 

examples/python/multiplex/multiplex_client.py

@@ -106,20 +106,23 @@ def guide_route_chat(route_guide_stub):
 
 
 def run():
-    channel = grpc.insecure_channel('localhost:50051')
-    greeter_stub = helloworld_pb2_grpc.GreeterStub(channel)
-    route_guide_stub = route_guide_pb2_grpc.RouteGuideStub(channel)
-    greeter_response = greeter_stub.SayHello(
-        helloworld_pb2.HelloRequest(name='you'))
-    print("Greeter client received: " + greeter_response.message)
-    print("-------------- GetFeature --------------")
-    guide_get_feature(route_guide_stub)
-    print("-------------- ListFeatures --------------")
-    guide_list_features(route_guide_stub)
-    print("-------------- RecordRoute --------------")
-    guide_record_route(route_guide_stub)
-    print("-------------- RouteChat --------------")
-    guide_route_chat(route_guide_stub)
+    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
+    # used in circumstances in which the with statement does not fit the needs
+    # of the code.
+    with grpc.insecure_channel('localhost:50051') as channel:
+        greeter_stub = helloworld_pb2_grpc.GreeterStub(channel)
+        route_guide_stub = route_guide_pb2_grpc.RouteGuideStub(channel)
+        greeter_response = greeter_stub.SayHello(
+            helloworld_pb2.HelloRequest(name='you'))
+        print("Greeter client received: " + greeter_response.message)
+        print("-------------- GetFeature --------------")
+        guide_get_feature(route_guide_stub)
+        print("-------------- ListFeatures --------------")
+        guide_list_features(route_guide_stub)
+        print("-------------- RecordRoute --------------")
+        guide_record_route(route_guide_stub)
+        print("-------------- RouteChat --------------")
+        guide_route_chat(route_guide_stub)
 
 
 if __name__ == '__main__':

examples/python/route_guide/route_guide_client.py

@@ -100,16 +100,19 @@ def guide_route_chat(stub):
 
 
 def run():
-    channel = grpc.insecure_channel('localhost:50051')
-    stub = route_guide_pb2_grpc.RouteGuideStub(channel)
-    print("-------------- GetFeature --------------")
-    guide_get_feature(stub)
-    print("-------------- ListFeatures --------------")
-    guide_list_features(stub)
-    print("-------------- RecordRoute --------------")
-    guide_record_route(stub)
-    print("-------------- RouteChat --------------")
-    guide_route_chat(stub)
+    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
+    # used in circumstances in which the with statement does not fit the needs
+    # of the code.
+    with grpc.insecure_channel('localhost:50051') as channel:
+        stub = route_guide_pb2_grpc.RouteGuideStub(channel)
+        print("-------------- GetFeature --------------")
+        guide_get_feature(stub)
+        print("-------------- ListFeatures --------------")
+        guide_list_features(stub)
+        print("-------------- RecordRoute --------------")
+        guide_record_route(stub)
+        print("-------------- RouteChat --------------")
+        guide_route_chat(stub)
 
 
 if __name__ == '__main__':

gRPC-C++.podspec

@@ -23,7 +23,7 @@
 Pod::Spec.new do |s|
   s.name     = 'gRPC-C++'
   # TODO (mxyan): use version that match gRPC version when pod is stabilized
-  # version = '1.13.0-dev'
+  # version = '1.14.0-dev'
   version = '0.0.2'
   s.version  = version
   s.summary  = 'gRPC C++ library'
@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
   s.license  = 'Apache License, Version 2.0'
   s.authors  = { 'The gRPC contributors' => 'grpc-packages@google.com' }
 
-  grpc_version = '1.13.0-dev'
+  grpc_version = '1.14.0-dev'
 
   s.source = {
     :git => 'https://github.com/grpc/grpc.git',
@@ -665,9 +665,9 @@ Pod::Spec.new do |s|
   end
 
   s.prepare_command = <<-END_OF_COMMAND
-    find src/cpp/ -type f -exec sed -E -i'.back' 's;#include "third_party/nanopb/(.*)";#include <nanopb/\\1>;g' {} \\\;
-    find src/cpp/ -name "*.back" -type f -delete
-    find src/core/ -regex ".*\.h" -type f -exec sed -E -i'.back' 's;#include "third_party/nanopb/(.*)";#include <nanopb/\\1>;g' {} \\\;
-    find src/core/ -name "*.back" -type f -delete
+    find src/cpp/ -type f ! -path '*.grpc_back' -print0 | xargs -0 -L1 sed -E -i'.grpc_back' 's;#include "(pb(_.*)?\\.h)";#include <nanopb/\\1>;g'
+    find src/cpp/ -type f -path '*.grpc_back' -print0 | xargs -0 rm
+    find src/core/ -type f ! -path '*.grpc_back' -print0 | xargs -0 -L1 sed -E -i'.grpc_back' 's;#include "(pb(_.*)?\\.h)";#include <nanopb/\\1>;g'
+    find src/core/ -type f -path '*.grpc_back' -print0 | xargs -0 rm
   END_OF_COMMAND
 end

gRPC-Core.podspec

@@ -22,7 +22,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC-Core'
-  version = '1.13.0-dev'
+  version = '1.14.0-dev'
   s.version  = version
   s.summary  = 'Core cross-platform gRPC library, written in C'
   s.homepage = 'https://grpc.io'
@@ -1268,6 +1268,7 @@ Pod::Spec.new do |s|
 
   # TODO (mxyan): Instead of this hack, add include path "third_party" to C core's include path?
   s.prepare_command = <<-END_OF_COMMAND
-    find src/core/ -type f ! -path '*.back*' -exec sed -E -i'.back' 's;#include "third_party/nanopb/(.*)";#include <nanopb/\\1>;g' {} \\\;
+    find src/core/ -type f ! -path '*.grpc_back' -print0 | xargs -0 -L1 sed -E -i'.grpc_back' 's;#include "(pb(_.*)?\\.h)";#include <nanopb/\\1>;g'
+    find src/core/ -type f -path '*.grpc_back' -print0 | xargs -0 rm
   END_OF_COMMAND
 end

gRPC-ProtoRPC.podspec

@@ -21,7 +21,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC-ProtoRPC'
-  version = '1.13.0-dev'
+  version = '1.14.0-dev'
   s.version  = version
   s.summary  = 'RPC library for Protocol Buffers, based on gRPC'
   s.homepage = 'https://grpc.io'

gRPC-RxLibrary.podspec

@@ -21,7 +21,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC-RxLibrary'
-  version = '1.13.0-dev'
+  version = '1.14.0-dev'
   s.version  = version
   s.summary  = 'Reactive Extensions library for iOS/OSX.'
   s.homepage = 'https://grpc.io'

gRPC.podspec

@@ -20,7 +20,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC'
-  version = '1.13.0-dev'
+  version = '1.14.0-dev'
   s.version  = version
   s.summary  = 'gRPC client library for iOS/OSX'
   s.homepage = 'https://grpc.io'

grpc.gyp

@@ -59,6 +59,8 @@
       '-Wno-unused-parameter',
       '-DOSATOMIC_USE_INLINED=1',
       '-Wno-deprecated-declarations',
+      '-Ithird_party/nanopb',
+      '-DPB_FIELD_32BIT',
     ],
     'ldflags': [
       '-g',
@@ -137,6 +139,8 @@
             '-Wno-unused-parameter',
             '-DOSATOMIC_USE_INLINED=1',
             '-Wno-deprecated-declarations',
+            '-Ithird_party/nanopb',
+            '-DPB_FIELD_32BIT',
           ],
           'OTHER_CPLUSPLUSFLAGS': [
             '-g',
@@ -147,6 +151,8 @@
             '-Wno-unused-parameter',
             '-DOSATOMIC_USE_INLINED=1',
             '-Wno-deprecated-declarations',
+            '-Ithird_party/nanopb',
+            '-DPB_FIELD_32BIT',
             '-stdlib=libc++',
             '-std=c++11',
             '-Wno-error=deprecated-declarations',

package.xml

@@ -13,8 +13,8 @@
  <date>2018-01-19</date>
  <time>16:06:07</time>
  <version>
-  <release>1.13.0dev</release>
-  <api>1.13.0dev</api>
+  <release>1.14.0dev</release>
+  <api>1.14.0dev</api>
  </version>
  <stability>
   <release>beta</release>

setup.py

@@ -37,6 +37,7 @@ PYTHON_STEM = os.path.join('src', 'python', 'grpcio')
 CORE_INCLUDE = ('include', '.',)
 SSL_INCLUDE = (os.path.join('third_party', 'boringssl', 'include'),)
 ZLIB_INCLUDE = (os.path.join('third_party', 'zlib'),)
+NANOPB_INCLUDE = (os.path.join('third_party', 'nanopb'),)
 CARES_INCLUDE = (
     os.path.join('third_party', 'cares'),
     os.path.join('third_party', 'cares', 'cares'),)
@@ -181,7 +182,7 @@ if BUILD_WITH_SYSTEM_CARES:
 
 EXTENSION_INCLUDE_DIRECTORIES = (
     (PYTHON_STEM,) + CORE_INCLUDE + SSL_INCLUDE + ZLIB_INCLUDE +
-    CARES_INCLUDE + ADDRESS_SORTING_INCLUDE)
+    NANOPB_INCLUDE + CARES_INCLUDE + ADDRESS_SORTING_INCLUDE)
 
 EXTENSION_LIBRARIES = ()
 if "linux" in sys.platform:

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

@@ -327,14 +327,16 @@ static void on_resolver_result_changed_locked(void* arg, grpc_error* error) {
   if (chand->resolver_result != nullptr) {
     if (chand->resolver != nullptr) {
       // Find LB policy name.
-      const char* lb_policy_name = grpc_channel_args_get_string(
+      const grpc_arg* channel_arg = grpc_channel_args_find(
           chand->resolver_result, GRPC_ARG_LB_POLICY_NAME);
+      const char* lb_policy_name = grpc_channel_arg_get_string(channel_arg);
       // Special case: If at least one balancer address is present, we use
       // the grpclb policy, regardless of what the resolver actually specified.
-      grpc_lb_addresses* addresses =
-          grpc_channel_args_get_pointer<grpc_lb_addresses>(
-              chand->resolver_result, GRPC_ARG_LB_ADDRESSES);
-      if (addresses != nullptr) {
+      channel_arg =
+          grpc_channel_args_find(chand->resolver_result, GRPC_ARG_LB_ADDRESSES);
+      if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_POINTER) {
+        grpc_lb_addresses* addresses =
+            static_cast<grpc_lb_addresses*>(channel_arg->value.pointer.p);
         bool found_balancer_address = false;
         for (size_t i = 0; i < addresses->num_addresses; ++i) {
           if (addresses->addresses[i].is_balancer) {
@@ -398,15 +400,18 @@ static void on_resolver_result_changed_locked(void* arg, grpc_error* error) {
       // The copy will be saved in chand->lb_policy_name below.
       lb_policy_name_dup = gpr_strdup(lb_policy_name);
       // Find service config.
-      service_config_json = gpr_strdup(grpc_channel_args_get_string(
-          chand->resolver_result, GRPC_ARG_SERVICE_CONFIG));
+      channel_arg = grpc_channel_args_find(chand->resolver_result,
+                                           GRPC_ARG_SERVICE_CONFIG);
+      service_config_json =
+          gpr_strdup(grpc_channel_arg_get_string(channel_arg));
       if (service_config_json != nullptr) {
         grpc_core::UniquePtr<grpc_core::ServiceConfig> service_config =
             grpc_core::ServiceConfig::Create(service_config_json);
         if (service_config != nullptr) {
           if (chand->enable_retries) {
-            const char* server_uri = grpc_channel_args_get_string(
-                chand->resolver_result, GRPC_ARG_SERVER_URI);
+            channel_arg = grpc_channel_args_find(chand->resolver_result,
+                                                 GRPC_ARG_SERVER_URI);
+            const char* server_uri = grpc_channel_arg_get_string(channel_arg);
             GPR_ASSERT(server_uri != nullptr);
             grpc_uri* uri = grpc_uri_parse(server_uri, true);
             GPR_ASSERT(uri->path[0] != '\0');
@@ -643,37 +648,45 @@ static grpc_error* cc_init_channel_elem(grpc_channel_element* elem,
                                "client_channel");
   grpc_client_channel_start_backup_polling(chand->interested_parties);
   // Record max per-RPC retry buffer size.
-  chand->per_rpc_retry_buffer_size = (size_t)grpc_channel_args_get_integer(
-      args->channel_args, GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE,
-      {DEFAULT_PER_RPC_RETRY_BUFFER_SIZE, 0, INT_MAX});
+  const grpc_arg* arg = grpc_channel_args_find(
+      args->channel_args, GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE);
+  chand->per_rpc_retry_buffer_size = (size_t)grpc_channel_arg_get_integer(
+      arg, {DEFAULT_PER_RPC_RETRY_BUFFER_SIZE, 0, INT_MAX});
   // Record enable_retries.
-  chand->enable_retries = grpc_channel_args_get_bool(
-      args->channel_args, GRPC_ARG_ENABLE_RETRIES, true);
+  arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_ENABLE_RETRIES);
+  chand->enable_retries = grpc_channel_arg_get_bool(arg, true);
   // Record client channel factory.
-  grpc_client_channel_factory* client_channel_factory =
-      grpc_channel_args_get_pointer<grpc_client_channel_factory>(
-          args->channel_args, GRPC_ARG_CLIENT_CHANNEL_FACTORY);
-  if (client_channel_factory == nullptr) {
+  arg = grpc_channel_args_find(args->channel_args,
+                               GRPC_ARG_CLIENT_CHANNEL_FACTORY);
+  if (arg == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Missing or malformed client channel factory in args for client "
-        "channel filter");
+        "Missing client channel factory in args for client channel filter");
   }
-  grpc_client_channel_factory_ref(client_channel_factory);
-  chand->client_channel_factory = client_channel_factory;
+  if (arg->type != GRPC_ARG_POINTER) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "client channel factory arg must be a pointer");
+  }
+  grpc_client_channel_factory_ref(
+      static_cast<grpc_client_channel_factory*>(arg->value.pointer.p));
+  chand->client_channel_factory =
+      static_cast<grpc_client_channel_factory*>(arg->value.pointer.p);
   // Get server name to resolve, using proxy mapper if needed.
-  char* server_uri =
-      grpc_channel_args_get_string(args->channel_args, GRPC_ARG_SERVER_URI);
-  if (server_uri == nullptr) {
+  arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVER_URI);
+  if (arg == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Missing server uri in args for client channel filter");
+  }
+  if (arg->type != GRPC_ARG_STRING) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Missing or malformed server uri in args for client channel filter");
+        "server uri arg must be a string");
   }
   char* proxy_name = nullptr;
   grpc_channel_args* new_args = nullptr;
-  grpc_proxy_mappers_map_name(server_uri, args->channel_args, &proxy_name,
-                              &new_args);
+  grpc_proxy_mappers_map_name(arg->value.string, args->channel_args,
+                              &proxy_name, &new_args);
   // Instantiate resolver.
   chand->resolver = grpc_core::ResolverRegistry::CreateResolver(
-      proxy_name != nullptr ? proxy_name : server_uri,
+      proxy_name != nullptr ? proxy_name : arg->value.string,
       new_args != nullptr ? new_args : args->channel_args,
       chand->interested_parties, chand->combiner);
   if (proxy_name != nullptr) gpr_free(proxy_name);

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

@@ -254,8 +254,9 @@ static void http_connect_handshaker_do_handshake(
       reinterpret_cast<http_connect_handshaker*>(handshaker_in);
   // Check for HTTP CONNECT channel arg.
   // If not found, invoke on_handshake_done without doing anything.
-  char* server_name =
-      grpc_channel_args_get_string(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
+  const grpc_arg* arg =
+      grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
+  char* server_name = grpc_channel_arg_get_string(arg);
   if (server_name == nullptr) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
@@ -266,8 +267,8 @@ static void http_connect_handshaker_do_handshake(
     return;
   }
   // Get headers from channel args.
-  char* arg_header_string =
-      grpc_channel_args_get_string(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
+  arg = grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
+  char* arg_header_string = grpc_channel_arg_get_string(arg);
   grpc_http_header* headers = nullptr;
   size_t num_headers = 0;
   char** header_strings = nullptr;

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

@@ -37,17 +37,21 @@
 #include "src/core/lib/slice/b64.h"
 
 /**
- * Parses the 'http_proxy' env var and returns the proxy hostname to resolve or
- * nullptr on error. Also sets 'user_cred' to user credentials if present in the
- * 'http_proxy' env var, otherwise leaves it unchanged. It is caller's
- * responsibility to gpr_free user_cred.
+ * Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
+ * proxy hostname to resolve or nullptr on error. Also sets 'user_cred' to user
+ * credentials if present in the 'http_proxy' env var, otherwise leaves it
+ * unchanged. It is caller's responsibility to gpr_free user_cred.
  */
 static char* get_http_proxy_server(char** user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   char* proxy_name = nullptr;
-  char* uri_str = gpr_getenv("http_proxy");
   char** authority_strs = nullptr;
   size_t authority_nstrs;
+  /* Prefer using 'https_proxy'. Fallback on 'http_proxy' if it is not set. The
+   * fallback behavior can be removed if there's a demand for it.
+   */
+  char* uri_str = gpr_getenv("https_proxy");
+  if (uri_str == nullptr) uri_str = gpr_getenv("http_proxy");
   if (uri_str == nullptr) return nullptr;
   grpc_uri* uri = grpc_uri_parse(uri_str, false /* suppress_errors */);
   if (uri == nullptr || uri->authority == nullptr) {
@@ -88,7 +92,9 @@ done:
  * should be used.
  */
 bool http_proxy_enabled(const grpc_channel_args* args) {
-  return grpc_channel_args_get_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true);
+  const grpc_arg* arg =
+      grpc_channel_args_find(args, GRPC_ARG_ENABLE_HTTP_PROXY);
+  return grpc_channel_arg_get_bool(arg, true);
 }
 
 static bool proxy_mapper_map_name(grpc_proxy_mapper* mapper,

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

@@ -1045,8 +1045,8 @@ GrpcLb::GrpcLb(const grpc_lb_addresses* addresses,
                     grpc_combiner_scheduler(args.combiner));
   grpc_connectivity_state_init(&state_tracker_, GRPC_CHANNEL_IDLE, "grpclb");
   // Record server name.
-  const char* server_uri =
-      grpc_channel_args_get_string(args.args, GRPC_ARG_SERVER_URI);
+  const grpc_arg* arg = grpc_channel_args_find(args.args, GRPC_ARG_SERVER_URI);
+  const char* server_uri = grpc_channel_arg_get_string(arg);
   GPR_ASSERT(server_uri != nullptr);
   grpc_uri* uri = grpc_uri_parse(server_uri, true);
   GPR_ASSERT(uri->path[0] != '\0');
@@ -1058,12 +1058,12 @@ GrpcLb::GrpcLb(const grpc_lb_addresses* addresses,
   }
   grpc_uri_destroy(uri);
   // Record LB call timeout.
-  lb_call_timeout_ms_ = grpc_channel_args_get_integer(
-      args.args, GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS, {0, 0, INT_MAX});
+  arg = grpc_channel_args_find(args.args, GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS);
+  lb_call_timeout_ms_ = grpc_channel_arg_get_integer(arg, {0, 0, INT_MAX});
   // Record fallback timeout.
-  lb_fallback_timeout_ms_ = grpc_channel_args_get_integer(
-      args.args, GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS,
-      {GRPC_GRPCLB_DEFAULT_FALLBACK_TIMEOUT_MS, 0, INT_MAX});
+  arg = grpc_channel_args_find(args.args, GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS);
+  lb_fallback_timeout_ms_ = grpc_channel_arg_get_integer(
+      arg, {GRPC_GRPCLB_DEFAULT_FALLBACK_TIMEOUT_MS, 0, INT_MAX});
   // Process channel args.
   ProcessChannelArgsLocked(*args.args);
 }
@@ -1284,10 +1284,8 @@ void GrpcLb::NotifyOnStateChangeLocked(grpc_connectivity_state* current,
 }
 
 void GrpcLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
-  const grpc_lb_addresses* addresses =
-      grpc_channel_args_get_pointer<grpc_lb_addresses>(&args,
-                                                       GRPC_ARG_LB_ADDRESSES);
-  if (GPR_UNLIKELY(addresses == nullptr)) {
+  const grpc_arg* arg = grpc_channel_args_find(&args, GRPC_ARG_LB_ADDRESSES);
+  if (GPR_UNLIKELY(arg == nullptr || arg->type != GRPC_ARG_POINTER)) {
     // Ignore this update.
     gpr_log(
         GPR_ERROR,
@@ -1295,6 +1293,8 @@ void GrpcLb::ProcessChannelArgsLocked(const grpc_channel_args& args) {
         this);
     return;
   }
+  const grpc_lb_addresses* addresses =
+      static_cast<const grpc_lb_addresses*>(arg->value.pointer.p);
   // Update fallback address list.
   if (fallback_backend_addresses_ != nullptr) {
     grpc_lb_addresses_destroy(fallback_backend_addresses_);
@@ -1860,12 +1860,13 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       const LoadBalancingPolicy::Args& args) const override {
     /* Count the number of gRPC-LB addresses. There must be at least one. */
-    grpc_lb_addresses* addresses =
-        grpc_channel_args_get_pointer<grpc_lb_addresses>(args.args,
-                                                         GRPC_ARG_LB_ADDRESSES);
-    if (addresses == nullptr) {
+    const grpc_arg* arg =
+        grpc_channel_args_find(args.args, GRPC_ARG_LB_ADDRESSES);
+    if (arg == nullptr || arg->type != GRPC_ARG_POINTER) {
       return nullptr;
     }
+    grpc_lb_addresses* addresses =
+        static_cast<grpc_lb_addresses*>(arg->value.pointer.p);
     size_t num_grpclb_addrs = 0;
     for (size_t i = 0; i < addresses->num_addresses; ++i) {
       if (addresses->addresses[i].is_balancer) ++num_grpclb_addrs;
@@ -1892,9 +1893,10 @@ bool maybe_add_client_load_reporting_filter(grpc_channel_stack_builder* builder,
                                             void* arg) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
-  const char* lb_policy =
-      grpc_channel_args_get_string(args, GRPC_ARG_LB_POLICY_NAME);
-  if (lb_policy != nullptr && strcmp(lb_policy, "grpclb") == 0) {
+  const grpc_arg* channel_arg =
+      grpc_channel_args_find(args, GRPC_ARG_LB_POLICY_NAME);
+  if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_STRING &&
+      strcmp(channel_arg->value.string, "grpclb") == 0) {
     return grpc_channel_stack_builder_append_filter(
         builder, (const grpc_channel_filter*)arg, nullptr, nullptr);
   }

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

@@ -72,10 +72,11 @@ grpc_channel_args* grpc_lb_policy_grpclb_modify_lb_channel_args(
   grpc_arg args_to_add[2];
   size_t num_args_to_add = 0;
   // Add arg for targets info table.
+  const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_LB_ADDRESSES);
+  GPR_ASSERT(arg != nullptr);
+  GPR_ASSERT(arg->type == GRPC_ARG_POINTER);
   grpc_lb_addresses* addresses =
-      grpc_channel_args_get_pointer<grpc_lb_addresses>(args,
-                                                       GRPC_ARG_LB_ADDRESSES);
-  GPR_ASSERT(addresses != nullptr);
+      static_cast<grpc_lb_addresses*>(arg->value.pointer.p);
   grpc_core::RefCountedPtr<grpc_core::TargetAuthorityTable>
       target_authority_table = grpc_core::CreateTargetAuthorityTable(addresses);
   args_to_add[num_args_to_add++] =

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

@@ -18,9 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "pb_decode.h"
+#include "pb_encode.h"
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h"
-#include "third_party/nanopb/pb_decode.h"
-#include "third_party/nanopb/pb_encode.h"
 
 #include <grpc/support/alloc.h>
 

src/core/ext/filters/client_channel/lb_policy/grpclb/proto/grpc/lb/v1/load_balancer.pb.h

@@ -3,7 +3,7 @@
 
 #ifndef PB_GRPC_LB_V1_LOAD_BALANCER_PB_H_INCLUDED
 #define PB_GRPC_LB_V1_LOAD_BALANCER_PB_H_INCLUDED
-#include "third_party/nanopb/pb.h"
+#include "pb.h"
 /* @@protoc_insertion_point(includes) */
 #if PB_PROTO_HEADER_VERSION != 30
 #error Regenerate this file with the current version of nanopb generator.

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

@@ -281,10 +281,8 @@ void PickFirst::PingOneLocked(grpc_closure* on_initiate, grpc_closure* on_ack) {
 }
 
 void PickFirst::UpdateLocked(const grpc_channel_args& args) {
-  const grpc_lb_addresses* addresses =
-      grpc_channel_args_get_pointer<const grpc_lb_addresses>(
-          &args, GRPC_ARG_LB_ADDRESSES);
-  if (addresses == nullptr) {
+  const grpc_arg* arg = grpc_channel_args_find(&args, GRPC_ARG_LB_ADDRESSES);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) {
     if (subchannel_list_ == nullptr) {
       // If we don't have a current subchannel list, go into TRANSIENT FAILURE.
       grpc_connectivity_state_set(
@@ -300,6 +298,8 @@ void PickFirst::UpdateLocked(const grpc_channel_args& args) {
     }
     return;
   }
+  const grpc_lb_addresses* addresses =
+      static_cast<const grpc_lb_addresses*>(arg->value.pointer.p);
   if (grpc_lb_pick_first_trace.enabled()) {
     gpr_log(GPR_INFO,
             "Pick First %p received update with %" PRIuPTR " addresses", this,

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

@@ -607,10 +607,8 @@ void RoundRobin::PingOneLocked(grpc_closure* on_initiate,
 }
 
 void RoundRobin::UpdateLocked(const grpc_channel_args& args) {
-  grpc_lb_addresses* addresses =
-      grpc_channel_args_get_pointer<grpc_lb_addresses>(&args,
-                                                       GRPC_ARG_LB_ADDRESSES);
-  if (GPR_UNLIKELY(addresses == nullptr)) {
+  const grpc_arg* arg = grpc_channel_args_find(&args, GRPC_ARG_LB_ADDRESSES);
+  if (GPR_UNLIKELY(arg == nullptr || arg->type != GRPC_ARG_POINTER)) {
     gpr_log(GPR_ERROR, "[RR %p] update provided no addresses; ignoring", this);
     // If we don't have a current subchannel list, go into TRANSIENT_FAILURE.
     // Otherwise, keep using the current subchannel list (ignore this update).
@@ -622,6 +620,8 @@ void RoundRobin::UpdateLocked(const grpc_channel_args& args) {
     }
     return;
   }
+  grpc_lb_addresses* addresses =
+      static_cast<grpc_lb_addresses*>(arg->value.pointer.p);
   if (grpc_lb_round_robin_trace.enabled()) {
     gpr_log(GPR_INFO, "[RR %p] received update with %" PRIuPTR " addresses",
             this, addresses->num_addresses);

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

@@ -147,6 +147,9 @@ grpc_arg grpc_lb_addresses_create_channel_arg(
 
 grpc_lb_addresses* grpc_lb_addresses_find_channel_arg(
     const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_pointer<grpc_lb_addresses>(
-      channel_args, GRPC_ARG_LB_ADDRESSES);
+  const grpc_arg* lb_addresses_arg =
+      grpc_channel_args_find(channel_args, GRPC_ARG_LB_ADDRESSES);
+  if (lb_addresses_arg == nullptr || lb_addresses_arg->type != GRPC_ARG_POINTER)
+    return nullptr;
+  return static_cast<grpc_lb_addresses*>(lb_addresses_arg->value.pointer.p);
 }

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

@@ -140,11 +140,14 @@ AresDnsResolver::AresDnsResolver(const ResolverArgs& args)
     dns_server_ = gpr_strdup(args.uri->authority);
   }
   channel_args_ = grpc_channel_args_copy(args.args);
-  request_service_config_ = !grpc_channel_args_get_bool(
-      channel_args_, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION, false);
-  min_time_between_resolutions_ = grpc_channel_args_get_integer(
-      channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-      {1000, 0, INT_MAX});
+  const grpc_arg* arg = grpc_channel_args_find(
+      channel_args_, GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION);
+  request_service_config_ = !grpc_channel_arg_get_integer(
+      arg, (grpc_integer_options){false, false, true});
+  arg = grpc_channel_args_find(channel_args_,
+                               GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
+  min_time_between_resolutions_ =
+      grpc_channel_arg_get_integer(arg, {1000, 0, INT_MAX});
   interested_parties_ = grpc_pollset_set_create();
   if (args.pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);

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

@@ -116,9 +116,10 @@ NativeDnsResolver::NativeDnsResolver(const ResolverArgs& args)
   if (path[0] == '/') ++path;
   name_to_resolve_ = gpr_strdup(path);
   channel_args_ = grpc_channel_args_copy(args.args);
-  min_time_between_resolutions_ = grpc_channel_args_get_integer(
-      args.args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-      {1000, 0, INT_MAX});
+  const grpc_arg* arg = grpc_channel_args_find(
+      args.args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
+  min_time_between_resolutions_ =
+      grpc_channel_arg_get_integer(arg, {1000, 0, INT_MAX});
   interested_parties_ = grpc_pollset_set_create();
   if (args.pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);

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

@@ -252,15 +252,20 @@ static const grpc_arg_pointer_vtable response_generator_arg_vtable = {
 
 grpc_arg FakeResolverResponseGenerator::MakeChannelArg(
     FakeResolverResponseGenerator* generator) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR), generator,
-      &response_generator_arg_vtable);
+  grpc_arg arg;
+  arg.type = GRPC_ARG_POINTER;
+  arg.key = (char*)GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  arg.value.pointer.p = generator;
+  arg.value.pointer.vtable = &response_generator_arg_vtable;
+  return arg;
 }
 
 FakeResolverResponseGenerator* FakeResolverResponseGenerator::GetFromArgs(
     const grpc_channel_args* args) {
-  return grpc_channel_args_get_pointer<FakeResolverResponseGenerator>(
-      args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
+  const grpc_arg* arg =
+      grpc_channel_args_find(args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
+  return static_cast<FakeResolverResponseGenerator*>(arg->value.pointer.p);
 }
 
 //

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

@@ -736,8 +736,9 @@ void grpc_get_subchannel_address_arg(const grpc_channel_args* args,
 }
 
 const char* grpc_get_subchannel_address_uri_arg(const grpc_channel_args* args) {
-  const char* addr_str =
-      grpc_channel_args_get_string(args, GRPC_ARG_SUBCHANNEL_ADDRESS);
+  const grpc_arg* addr_arg =
+      grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_ADDRESS);
+  const char* addr_str = grpc_channel_arg_get_string(addr_arg);
   GPR_ASSERT(addr_str != nullptr);  // Should have been set by LB policy.
   return addr_str;
 }

src/core/ext/filters/deadline/deadline_filter.cc

@@ -358,8 +358,8 @@ const grpc_channel_filter grpc_server_deadline_filter = {
 };
 
 bool grpc_deadline_checking_enabled(const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_bool(
-      channel_args, GRPC_ARG_ENABLE_DEADLINE_CHECKS,
+  return grpc_channel_arg_get_bool(
+      grpc_channel_args_find(channel_args, GRPC_ARG_ENABLE_DEADLINE_CHECKS),
       !grpc_channel_args_want_minimal_stack(channel_args));
 }
 

src/core/ext/filters/http/client/http_client_filter.cc

@@ -23,7 +23,6 @@
 #include <stdint.h>
 #include <string.h>
 #include "src/core/ext/filters/http/client/http_client_filter.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -436,43 +435,64 @@ static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {}
 
-static grpc_mdelem scheme_from_args(const grpc_channel_args* channel_args) {
+static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
+  unsigned i;
+  size_t j;
   grpc_mdelem valid_schemes[] = {GRPC_MDELEM_SCHEME_HTTP,
                                  GRPC_MDELEM_SCHEME_HTTPS};
-  char* scheme =
-      grpc_channel_args_get_string(channel_args, GRPC_ARG_HTTP2_SCHEME);
-  if (scheme != nullptr) {
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(valid_schemes); i++) {
-      if (0 == grpc_slice_str_cmp(GRPC_MDVALUE(valid_schemes[i]), scheme)) {
-        return valid_schemes[i];
+  if (args != nullptr) {
+    for (i = 0; i < args->num_args; ++i) {
+      if (args->args[i].type == GRPC_ARG_STRING &&
+          strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0) {
+        for (j = 0; j < GPR_ARRAY_SIZE(valid_schemes); j++) {
+          if (0 == grpc_slice_str_cmp(GRPC_MDVALUE(valid_schemes[j]),
+                                      args->args[i].value.string)) {
+            return valid_schemes[j];
+          }
+        }
       }
     }
   }
   return GRPC_MDELEM_SCHEME_HTTP;
 }
 
-static size_t max_payload_size_from_args(
-    const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_integer(
-      channel_args, GRPC_ARG_MAX_PAYLOAD_SIZE_FOR_GET,
-      {kMaxPayloadSizeForGet, 0, kMaxPayloadSizeForGet});
+static size_t max_payload_size_from_args(const grpc_channel_args* args) {
+  if (args != nullptr) {
+    for (size_t i = 0; i < args->num_args; ++i) {
+      if (0 == strcmp(args->args[i].key, GRPC_ARG_MAX_PAYLOAD_SIZE_FOR_GET)) {
+        if (args->args[i].type != GRPC_ARG_INTEGER) {
+          gpr_log(GPR_ERROR, "%s: must be an integer",
+                  GRPC_ARG_MAX_PAYLOAD_SIZE_FOR_GET);
+        } else {
+          return static_cast<size_t>(args->args[i].value.integer);
+        }
+      }
+    }
+  }
+  return kMaxPayloadSizeForGet;
 }
 
 static grpc_slice user_agent_from_args(const grpc_channel_args* args,
                                        const char* transport_name) {
   gpr_strvec v;
+  size_t i;
   int is_first = 1;
   char* tmp;
   grpc_slice result;
 
   gpr_strvec_init(&v);
 
-  char* user_agent_str =
-      grpc_channel_args_get_string(args, GRPC_ARG_PRIMARY_USER_AGENT_STRING);
-  if (user_agent_str != nullptr) {
-    if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-    is_first = 0;
-    gpr_strvec_add(&v, gpr_strdup(user_agent_str));
+  for (i = 0; args && i < args->num_args; i++) {
+    if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
+      if (args->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                GRPC_ARG_PRIMARY_USER_AGENT_STRING);
+      } else {
+        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
+        is_first = 0;
+        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+      }
+    }
   }
 
   gpr_asprintf(&tmp, "%sgrpc-c/%s (%s; %s; %s)", is_first ? "" : " ",
@@ -481,11 +501,17 @@ static grpc_slice user_agent_from_args(const grpc_channel_args* args,
   is_first = 0;
   gpr_strvec_add(&v, tmp);
 
-  user_agent_str =
-      grpc_channel_args_get_string(args, GRPC_ARG_SECONDARY_USER_AGENT_STRING);
-  if (user_agent_str != nullptr) {
-    gpr_strvec_add(&v, gpr_strdup(" "));
-    gpr_strvec_add(&v, gpr_strdup(user_agent_str));
+  for (i = 0; args && i < args->num_args; i++) {
+    if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
+      if (args->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                GRPC_ARG_SECONDARY_USER_AGENT_STRING);
+      } else {
+        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
+        is_first = 0;
+        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+      }
+    }
   }
 
   tmp = gpr_strvec_flatten(&v, nullptr);

src/core/ext/filters/http/http_filters_plugin.cc

@@ -48,8 +48,8 @@ static bool maybe_add_optional_filter(grpc_channel_stack_builder* builder,
   optional_filter* filtarg = static_cast<optional_filter*>(arg);
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
-  bool enable = grpc_channel_args_get_bool(
-      channel_args, filtarg->control_channel_arg,
+  bool enable = grpc_channel_arg_get_bool(
+      grpc_channel_args_find(channel_args, filtarg->control_channel_arg),
       !grpc_channel_args_want_minimal_stack(channel_args));
   return enable ? grpc_channel_stack_builder_prepend_filter(
                       builder, filtarg->filter, nullptr, nullptr)

src/core/ext/filters/http/server/http_server_filter.h

@@ -23,7 +23,7 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-/* Processes metadata on the client side for HTTP2 transports */
+/* Processes metadata on the server side for HTTP2 transports */
 extern const grpc_channel_filter grpc_http_server_filter;
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H */

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

@@ -33,7 +33,8 @@
 #include "src/core/lib/surface/channel_init.h"
 
 static bool is_load_reporting_enabled(const grpc_channel_args* a) {
-  return grpc_channel_args_get_bool(a, GRPC_ARG_ENABLE_LOAD_REPORTING, false);
+  return grpc_channel_arg_get_bool(
+      grpc_channel_args_find(a, GRPC_ARG_ENABLE_LOAD_REPORTING), false);
 }
 
 static bool maybe_add_server_load_reporting_filter(

src/core/ext/filters/max_age/max_age_filter.cc

@@ -519,12 +519,13 @@ static bool maybe_add_max_age_filter(grpc_channel_stack_builder* builder,
                                      void* arg) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
-  bool enable = grpc_channel_args_get_integer(
-                    channel_args, GRPC_ARG_MAX_CONNECTION_AGE_MS,
-                    MAX_CONNECTION_AGE_INTEGER_OPTIONS) != INT_MAX ||
-                grpc_channel_args_get_integer(
-                    channel_args, GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                    MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX;
+  bool enable =
+      grpc_channel_arg_get_integer(
+          grpc_channel_args_find(channel_args, GRPC_ARG_MAX_CONNECTION_AGE_MS),
+          MAX_CONNECTION_AGE_INTEGER_OPTIONS) != INT_MAX ||
+      grpc_channel_arg_get_integer(
+          grpc_channel_args_find(channel_args, GRPC_ARG_MAX_CONNECTION_IDLE_MS),
+          MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX;
   if (enable) {
     return grpc_channel_stack_builder_prepend_filter(
         builder, &grpc_max_age_filter, nullptr, nullptr);

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

@@ -254,8 +254,9 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   chand->limits = get_message_size_limits(args->channel_args);
   // Get method config table from channel args.
-  const char* service_config_str =
-      grpc_channel_args_get_string(args->channel_args, GRPC_ARG_SERVICE_CONFIG);
+  const grpc_arg* channel_arg =
+      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::ServiceConfig::Create(service_config_str);

src/core/ext/transport/chttp2/client/authority.cc

@@ -28,8 +28,9 @@ grpc_channel_args* grpc_default_authority_add_if_not_present(
   size_t num_new_args = 0;
   grpc_core::UniquePtr<char> default_authority;
   if (!has_default_authority) {
-    const char* server_uri_str =
-        grpc_channel_args_get_string(args, GRPC_ARG_SERVER_URI);
+    const grpc_arg* server_uri_arg =
+        grpc_channel_args_find(args, GRPC_ARG_SERVER_URI);
+    const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
     GPR_ASSERT(server_uri_str != nullptr);
     default_authority =
         grpc_core::ResolverRegistry::GetDefaultAuthority(server_uri_str);

src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -64,8 +64,9 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     return nullptr;
   }
   // To which address are we connecting? By default, use the server URI.
-  const char* server_uri_str =
-      grpc_channel_args_get_string(args->args, GRPC_ARG_SERVER_URI);
+  const grpc_arg* server_uri_arg =
+      grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI);
+  const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
   GPR_ASSERT(server_uri_str != nullptr);
   grpc_uri* server_uri =
       grpc_uri_parse(server_uri_str, true /* supress errors */);

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

@@ -447,19 +447,20 @@ static void init_transport(grpc_chttp2_transport* t,
             grpc_channel_arg_get_integer(&channel_args->args[i], {0, 0, 1}));
       } else if (0 == strcmp(channel_args->args[i].key,
                              GRPC_ARG_OPTIMIZATION_TARGET)) {
-        char* opt_target_str =
-            grpc_channel_arg_get_string(&channel_args->args[i]);
-        if (opt_target_str == nullptr) {
-          gpr_log(GPR_ERROR, "null/missing value opt target, assuming 'blend'");
-        } else if (0 == strcmp(opt_target_str, "blend")) {
+        if (channel_args->args[i].type != GRPC_ARG_STRING) {
+          gpr_log(GPR_ERROR, "%s should be a string",
+                  GRPC_ARG_OPTIMIZATION_TARGET);
+        } else if (0 == strcmp(channel_args->args[i].value.string, "blend")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY;
-        } else if (0 == strcmp(opt_target_str, "latency")) {
+        } else if (0 == strcmp(channel_args->args[i].value.string, "latency")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY;
-        } else if (0 == strcmp(opt_target_str, "throughput")) {
+        } else if (0 ==
+                   strcmp(channel_args->args[i].value.string, "throughput")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT;
         } else {
           gpr_log(GPR_ERROR, "%s value '%s' unknown, assuming 'blend'",
-                  GRPC_ARG_OPTIMIZATION_TARGET, opt_target_str);
+                  GRPC_ARG_OPTIMIZATION_TARGET,
+                  channel_args->args[i].value.string);
         }
       } else {
         static const struct {

src/core/ext/transport/cronet/transport/cronet_transport.cc

@@ -1450,8 +1450,20 @@ grpc_transport* grpc_create_cronet_transport(void* engine, const char* target,
   }
   strcpy(ct->host, target);
 
-  ct->use_packet_coalescing = grpc_channel_args_get_bool(
-      args, GRPC_ARG_USE_CRONET_PACKET_COALESCING, true);
+  ct->use_packet_coalescing = true;
+  if (args) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      if (0 ==
+          strcmp(args->args[i].key, GRPC_ARG_USE_CRONET_PACKET_COALESCING)) {
+        if (GPR_UNLIKELY(args->args[i].type != GRPC_ARG_INTEGER)) {
+          gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
+                  GRPC_ARG_USE_CRONET_PACKET_COALESCING);
+        } else {
+          ct->use_packet_coalescing = (args->args[i].value.integer != 0);
+        }
+      }
+    }
+  }
 
   return &ct->base;
 

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

@@ -1204,9 +1204,10 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
   // Add a default authority channel argument for the client
 
-  grpc_arg default_authority_arg = grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
-      const_cast<char*>("inproc.authority"));
+  grpc_arg default_authority_arg;
+  default_authority_arg.type = GRPC_ARG_STRING;
+  default_authority_arg.key = (char*)GRPC_ARG_DEFAULT_AUTHORITY;
+  default_authority_arg.value.string = (char*)"inproc.authority";
   grpc_channel_args* client_args =
       grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
 

src/core/lib/channel/channel_args.h

@@ -23,7 +23,6 @@
 
 #include <grpc/compression.h>
 #include <grpc/grpc.h>
-#include <grpc/support/log.h>
 #include "src/core/lib/iomgr/socket_mutator.h"
 
 // Channel args are intentionally immutable, to avoid the need for locking.
@@ -111,49 +110,13 @@ typedef struct grpc_integer_options {
 /** Returns the value of \a arg, subject to the contraints in \a options. */
 int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options);
-/** convinience helper for the above that finds the arg first. */
-inline int grpc_channel_args_get_integer(const grpc_channel_args* args,
-                                         const char* name,
-                                         const grpc_integer_options options) {
-  return grpc_channel_arg_get_integer(grpc_channel_args_find(args, name),
-                                      options);
-}
 
 /** Returns the value of \a arg if \a arg is of type GRPC_ARG_STRING.
     Otherwise, emits a warning log, and returns nullptr.
     If arg is nullptr, returns nullptr, and does not emit a warning. */
 char* grpc_channel_arg_get_string(const grpc_arg* arg);
-/** convinience helper for the above that finds the arg first. */
-inline char* grpc_channel_args_get_string(const grpc_channel_args* args,
-                                          const char* name) {
-  return grpc_channel_arg_get_string(grpc_channel_args_find(args, name));
-}
-
-/** Returns the value of \a arg if \a arg is of type GRPC_ARG_POINTER
-    Otherwise, emits a warning log, and returns nullptr.
-    If arg is nullptr, returns nullptr, and does not emit a warning. */
-template <typename Type>
-inline Type* grpc_channel_arg_get_pointer(const grpc_arg* arg) {
-  if (arg == nullptr) return nullptr;
-  if (arg->type != GRPC_ARG_POINTER) {
-    gpr_log(GPR_ERROR, "%s ignored: it must be an pointer", arg->key);
-    return nullptr;
-  }
-  return static_cast<Type*>(arg->value.pointer.p);
-}
-/** convinience helper for the above that finds the arg first. */
-template <typename Type>
-inline Type* grpc_channel_args_get_pointer(const grpc_channel_args* args,
-                                           const char* name) {
-  return grpc_channel_arg_get_pointer<Type>(grpc_channel_args_find(args, name));
-}
 
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value);
-inline bool grpc_channel_args_get_bool(const grpc_channel_args* args,
-                                       const char* name, bool default_value) {
-  return grpc_channel_arg_get_bool(grpc_channel_args_find(args, name),
-                                   default_value);
-}
 
 // Helpers for creating channel args.
 grpc_arg grpc_channel_arg_string_create(char* name, char* value);

src/core/lib/iomgr/ev_epollex_linux.cc

@@ -33,6 +33,7 @@
 #include <poll.h>
 #include <pthread.h>
 #include <string.h>
+#include <sys/epoll.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <unistd.h>

src/core/lib/iomgr/is_epollexclusive_available.cc

@@ -27,6 +27,7 @@
 #include <grpc/support/log.h>
 
 #include <errno.h>
+#include <sys/epoll.h>
 #include <sys/eventfd.h>
 #include <unistd.h>
 

src/core/lib/iomgr/resource_quota.cc

@@ -30,7 +30,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/combiner.h"
 
@@ -671,9 +670,18 @@ size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota) {
 
 grpc_resource_quota* grpc_resource_quota_from_channel_args(
     const grpc_channel_args* channel_args) {
-  grpc_resource_quota* rq = grpc_channel_args_get_pointer<grpc_resource_quota>(
-      channel_args, GRPC_ARG_RESOURCE_QUOTA);
-  return rq == nullptr ? grpc_resource_quota_create(nullptr) : rq;
+  for (size_t i = 0; i < channel_args->num_args; i++) {
+    if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
+      if (channel_args->args[i].type == GRPC_ARG_POINTER) {
+        return grpc_resource_quota_ref_internal(
+            static_cast<grpc_resource_quota*>(
+                channel_args->args[i].value.pointer.p));
+      } else {
+        gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer");
+      }
+    }
+  }
+  return grpc_resource_quota_create(nullptr);
 }
 
 static void* rq_copy(void* rq) {

src/core/lib/iomgr/tcp_client_posix.cc

@@ -66,7 +66,6 @@ typedef struct {
 static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
                                   const grpc_channel_args* channel_args) {
   grpc_error* err = GRPC_ERROR_NONE;
-  grpc_socket_mutator* mutator = nullptr;
 
   GPR_ASSERT(fd >= 0);
 
@@ -80,11 +79,16 @@ static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
-  mutator = grpc_channel_args_get_pointer<grpc_socket_mutator>(
-      channel_args, GRPC_ARG_SOCKET_MUTATOR);
-  if (mutator != nullptr) {
-    err = grpc_set_socket_with_mutator(fd, mutator);
-    if (err != GRPC_ERROR_NONE) goto error;
+  if (channel_args) {
+    for (size_t i = 0; i < channel_args->num_args; i++) {
+      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
+        GPR_ASSERT(channel_args->args[i].type == GRPC_ARG_POINTER);
+        grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
+            channel_args->args[i].value.pointer.p);
+        err = grpc_set_socket_with_mutator(fd, mutator);
+        if (err != GRPC_ERROR_NONE) goto error;
+      }
+    }
   }
   goto done;
 

src/core/lib/iomgr/tcp_server_custom.cc

@@ -26,7 +26,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
@@ -81,9 +80,21 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
                                      const grpc_channel_args* args,
                                      grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
-  grpc_resource_quota* rq = grpc_channel_args_get_pointer<grpc_resource_quota>(
-      args, GRPC_ARG_RESOURCE_QUOTA);
-  s->resource_quota = rq == nullptr ? grpc_resource_quota_create(nullptr) : rq;
+  s->resource_quota = grpc_resource_quota_create(nullptr);
+  for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
+    if (0 == strcmp(GRPC_ARG_RESOURCE_QUOTA, args->args[i].key)) {
+      if (args->args[i].type == GRPC_ARG_POINTER) {
+        grpc_resource_quota_unref_internal(s->resource_quota);
+        s->resource_quota = grpc_resource_quota_ref_internal(
+            (grpc_resource_quota*)args->args[i].value.pointer.p);
+      } else {
+        grpc_resource_quota_unref_internal(s->resource_quota);
+        gpr_free(s);
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            GRPC_ARG_RESOURCE_QUOTA " must be a pointer to a buffer pool");
+      }
+    }
+  }
   gpr_ref_init(&s->refs, 1);
   s->on_accept_cb = nullptr;
   s->on_accept_cb_arg = nullptr;

src/core/lib/iomgr/tcp_server_posix.cc

@@ -64,11 +64,22 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
   s->expand_wildcard_addrs = false;
   for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
     if (0 == strcmp(GRPC_ARG_ALLOW_REUSEPORT, args->args[i].key)) {
-      s->so_reuseport = grpc_channel_arg_get_bool(
-          &args->args[i], grpc_is_socket_reuse_port_supported());
+      if (args->args[i].type == GRPC_ARG_INTEGER) {
+        s->so_reuseport = grpc_is_socket_reuse_port_supported() &&
+                          (args->args[i].value.integer != 0);
+      } else {
+        gpr_free(s);
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(GRPC_ARG_ALLOW_REUSEPORT
+                                                    " must be an integer");
+      }
     } else if (0 == strcmp(GRPC_ARG_EXPAND_WILDCARD_ADDRS, args->args[i].key)) {
-      s->expand_wildcard_addrs =
-          grpc_channel_arg_get_bool(&args->args[i], false);
+      if (args->args[i].type == GRPC_ARG_INTEGER) {
+        s->expand_wildcard_addrs = (args->args[i].value.integer != 0);
+      } else {
+        gpr_free(s);
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            GRPC_ARG_EXPAND_WILDCARD_ADDRS " must be an integer");
+      }
     }
   }
   gpr_ref_init(&s->refs, 1);

src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -34,7 +34,6 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
@@ -150,7 +149,6 @@ grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
                                            bool so_reuseport, int* port) {
   grpc_resolved_address sockname_temp;
   grpc_error* err = GRPC_ERROR_NONE;
-  grpc_socket_mutator* mutator = nullptr;
 
   GPR_ASSERT(fd >= 0);
 
@@ -171,11 +169,17 @@ grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
-  mutator = grpc_channel_args_get_pointer<grpc_socket_mutator>(
-      s->channel_args, GRPC_ARG_SOCKET_MUTATOR);
-  if (mutator != nullptr) {
-    err = grpc_set_socket_with_mutator(fd, mutator);
-    if (err != GRPC_ERROR_NONE) goto error;
+
+  if (s->channel_args) {
+    for (size_t i = 0; i < s->channel_args->num_args; i++) {
+      if (0 == strcmp(s->channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
+        GPR_ASSERT(s->channel_args->args[i].type == GRPC_ARG_POINTER);
+        grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
+            s->channel_args->args[i].value.pointer.p);
+        err = grpc_set_socket_with_mutator(fd, mutator);
+        if (err != GRPC_ERROR_NONE) goto error;
+      }
+    }
   }
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),

src/core/lib/iomgr/udp_server.cc

@@ -197,8 +197,14 @@ struct grpc_udp_server {
 };
 
 static grpc_socket_factory* get_socket_factory(const grpc_channel_args* args) {
-  return grpc_channel_args_get_pointer<grpc_socket_factory>(
-      args, GRPC_ARG_SOCKET_FACTORY);
+  if (args) {
+    const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_SOCKET_FACTORY);
+    if (arg) {
+      GPR_ASSERT(arg->type == GRPC_ARG_POINTER);
+      return static_cast<grpc_socket_factory*>(arg->value.pointer.p);
+    }
+  }
+  return nullptr;
 }
 
 grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args) {

src/core/lib/security/context/security_context.cc

@@ -326,8 +326,23 @@ grpc_arg grpc_auth_context_to_arg(grpc_auth_context* p) {
                                          &auth_context_pointer_vtable);
 }
 
+grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_AUTH_CONTEXT_ARG) != 0) return nullptr;
+  if (arg->type != GRPC_ARG_POINTER) {
+    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
+            GRPC_AUTH_CONTEXT_ARG);
+    return nullptr;
+  }
+  return static_cast<grpc_auth_context*>(arg->value.pointer.p);
+}
+
 grpc_auth_context* grpc_find_auth_context_in_args(
-    const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_pointer<grpc_auth_context>(
-      channel_args, GRPC_AUTH_CONTEXT_ARG);
+    const grpc_channel_args* args) {
+  size_t i;
+  if (args == nullptr) return nullptr;
+  for (i = 0; i < args->num_args; i++) {
+    grpc_auth_context* p = grpc_auth_context_from_arg(&args->args[i]);
+    if (p != nullptr) return p;
+  }
+  return nullptr;
 }

src/core/lib/security/context/security_context.h

@@ -108,6 +108,7 @@ void grpc_server_security_context_destroy(void* ctx);
 #define GRPC_AUTH_CONTEXT_ARG "grpc.auth_context"
 
 grpc_arg grpc_auth_context_to_arg(grpc_auth_context* c);
+grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg);
 grpc_auth_context* grpc_find_auth_context_in_args(
     const grpc_channel_args* args);
 

src/core/lib/security/credentials/credentials.cc

@@ -168,10 +168,27 @@ grpc_arg grpc_channel_credentials_to_arg(
                                          &credentials_pointer_vtable);
 }
 
+grpc_channel_credentials* grpc_channel_credentials_from_arg(
+    const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_ARG_CHANNEL_CREDENTIALS)) return nullptr;
+  if (arg->type != GRPC_ARG_POINTER) {
+    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
+            GRPC_ARG_CHANNEL_CREDENTIALS);
+    return nullptr;
+  }
+  return static_cast<grpc_channel_credentials*>(arg->value.pointer.p);
+}
+
 grpc_channel_credentials* grpc_channel_credentials_find_in_args(
-    const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_pointer<grpc_channel_credentials>(
-      channel_args, GRPC_ARG_CHANNEL_CREDENTIALS);
+    const grpc_channel_args* args) {
+  size_t i;
+  if (args == nullptr) return nullptr;
+  for (i = 0; i < args->num_args; i++) {
+    grpc_channel_credentials* credentials =
+        grpc_channel_credentials_from_arg(&args->args[i]);
+    if (credentials != nullptr) return credentials;
+  }
+  return nullptr;
 }
 
 grpc_server_credentials* grpc_server_credentials_ref(
@@ -246,8 +263,24 @@ grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials* p) {
                                          &cred_ptr_vtable);
 }
 
+grpc_server_credentials* grpc_server_credentials_from_arg(const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_SERVER_CREDENTIALS_ARG) != 0) return nullptr;
+  if (arg->type != GRPC_ARG_POINTER) {
+    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
+            GRPC_SERVER_CREDENTIALS_ARG);
+    return nullptr;
+  }
+  return static_cast<grpc_server_credentials*>(arg->value.pointer.p);
+}
+
 grpc_server_credentials* grpc_find_server_credentials_in_args(
-    const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_pointer<grpc_server_credentials>(
-      channel_args, GRPC_SERVER_CREDENTIALS_ARG);
+    const grpc_channel_args* args) {
+  size_t i;
+  if (args == nullptr) return nullptr;
+  for (i = 0; i < args->num_args; i++) {
+    grpc_server_credentials* p =
+        grpc_server_credentials_from_arg(&args->args[i]);
+    if (p != nullptr) return p;
+  }
+  return nullptr;
 }

src/core/lib/security/credentials/credentials.h

@@ -131,6 +131,10 @@ grpc_channel_credentials_duplicate_without_call_credentials(
 /* Util to encapsulate the channel credentials in a channel arg. */
 grpc_arg grpc_channel_credentials_to_arg(grpc_channel_credentials* credentials);
 
+/* Util to get the channel credentials from a channel arg. */
+grpc_channel_credentials* grpc_channel_credentials_from_arg(
+    const grpc_arg* arg);
+
 /* Util to find the channel credentials from channel args. */
 grpc_channel_credentials* grpc_channel_credentials_find_in_args(
     const grpc_channel_args* args);
@@ -223,6 +227,7 @@ void grpc_server_credentials_unref(grpc_server_credentials* creds);
 #define GRPC_SERVER_CREDENTIALS_ARG "grpc.server_credentials"
 
 grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials* c);
+grpc_server_credentials* grpc_server_credentials_from_arg(const grpc_arg* arg);
 grpc_server_credentials* grpc_find_server_credentials_in_args(
     const grpc_channel_args* args);
 

src/core/lib/security/credentials/fake/fake_credentials.cc

@@ -84,8 +84,9 @@ grpc_arg grpc_fake_transport_expected_targets_arg(char* expected_targets) {
 
 const char* grpc_fake_transport_get_expected_targets(
     const grpc_channel_args* args) {
-  return grpc_channel_args_get_string(args,
-                                      GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
+  const grpc_arg* expected_target_arg =
+      grpc_channel_args_find(args, GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
+  return grpc_channel_arg_get_string(expected_target_arg);
 }
 
 /* -- Metadata-only test credentials. -- */

src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -79,10 +79,13 @@ static grpc_security_status google_default_create_security_connector(
     grpc_channel_security_connector** sc, grpc_channel_args** new_args) {
   grpc_google_default_channel_credentials* c =
       reinterpret_cast<grpc_google_default_channel_credentials*>(creds);
-  bool is_grpclb_load_balancer = grpc_channel_args_get_bool(
-      args, GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER, false);
-  bool is_backend_from_grpclb_load_balancer = grpc_channel_args_get_bool(
-      args, GRPC_ARG_ADDRESS_IS_BACKEND_FROM_GRPCLB_LOAD_BALANCER, false);
+  bool is_grpclb_load_balancer = grpc_channel_arg_get_bool(
+      grpc_channel_args_find(args, GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER),
+      false);
+  bool is_backend_from_grpclb_load_balancer = grpc_channel_arg_get_bool(
+      grpc_channel_args_find(
+          args, GRPC_ARG_ADDRESS_IS_BACKEND_FROM_GRPCLB_LOAD_BALANCER),
+      false);
   bool use_alts =
       is_grpclb_load_balancer || is_backend_from_grpclb_load_balancer;
   grpc_security_status status = GRPC_SECURITY_ERROR;

src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -60,12 +60,14 @@ static grpc_security_status ssl_create_security_connector(
   tsi_ssl_session_cache* ssl_session_cache = nullptr;
   for (size_t i = 0; args && i < args->num_args; i++) {
     grpc_arg* arg = &args->args[i];
-    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0) {
-      overridden_target_name = grpc_channel_arg_get_string(arg);
+    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0 &&
+        arg->type == GRPC_ARG_STRING) {
+      overridden_target_name = arg->value.string;
     }
-    if (strcmp(arg->key, GRPC_SSL_SESSION_CACHE_ARG) == 0) {
+    if (strcmp(arg->key, GRPC_SSL_SESSION_CACHE_ARG) == 0 &&
+        arg->type == GRPC_ARG_POINTER) {
       ssl_session_cache =
-          grpc_channel_arg_get_pointer<tsi_ssl_session_cache>(arg);
+          static_cast<tsi_ssl_session_cache*>(arg->value.pointer.p);
     }
   }
   status = grpc_ssl_channel_security_connector_create(

src/core/lib/security/security_connector/security_connector.cc

@@ -255,10 +255,26 @@ grpc_arg grpc_security_connector_to_arg(grpc_security_connector* sc) {
                                          &connector_arg_vtable);
 }
 
+grpc_security_connector* grpc_security_connector_from_arg(const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_ARG_SECURITY_CONNECTOR)) return nullptr;
+  if (arg->type != GRPC_ARG_POINTER) {
+    gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
+            GRPC_ARG_SECURITY_CONNECTOR);
+    return nullptr;
+  }
+  return static_cast<grpc_security_connector*>(arg->value.pointer.p);
+}
+
 grpc_security_connector* grpc_security_connector_find_in_args(
-    const grpc_channel_args* channel_args) {
-  return grpc_channel_args_get_pointer<grpc_security_connector>(
-      channel_args, GRPC_ARG_SECURITY_CONNECTOR);
+    const grpc_channel_args* args) {
+  size_t i;
+  if (args == nullptr) return nullptr;
+  for (i = 0; i < args->num_args; i++) {
+    grpc_security_connector* sc =
+        grpc_security_connector_from_arg(&args->args[i]);
+    if (sc != nullptr) return sc;
+  }
+  return nullptr;
 }
 
 static tsi_client_certificate_request_type

src/core/lib/security/security_connector/security_connector.h

@@ -99,6 +99,9 @@ int grpc_security_connector_cmp(grpc_security_connector* sc,
 /* Util to encapsulate the connector in a channel arg. */
 grpc_arg grpc_security_connector_to_arg(grpc_security_connector* sc);
 
+/* Util to get the connector from a channel arg. */
+grpc_security_connector* grpc_security_connector_from_arg(const grpc_arg* arg);
+
 /* Util to find the connector from channel args. */
 grpc_security_connector* grpc_security_connector_find_in_args(
     const grpc_channel_args* args);

src/core/lib/security/transport/target_authority_table.cc

@@ -59,8 +59,17 @@ grpc_arg CreateTargetAuthorityTableChannelArg(TargetAuthorityTable* table) {
 
 TargetAuthorityTable* FindTargetAuthorityTableInArgs(
     const grpc_channel_args* args) {
-  return grpc_channel_args_get_pointer<TargetAuthorityTable>(
-      args, GRPC_ARG_TARGET_AUTHORITY_TABLE);
+  const grpc_arg* arg =
+      grpc_channel_args_find(args, GRPC_ARG_TARGET_AUTHORITY_TABLE);
+  if (arg != nullptr) {
+    if (arg->type == GRPC_ARG_POINTER) {
+      return static_cast<TargetAuthorityTable*>(arg->value.pointer.p);
+    } else {
+      gpr_log(GPR_ERROR, "value of " GRPC_ARG_TARGET_AUTHORITY_TABLE
+                         " channel arg was not pointer type; ignoring");
+    }
+  }
+  return nullptr;
 }
 
 }  // namespace grpc_core

src/core/lib/surface/version.cc

@@ -25,4 +25,4 @@
 
 const char* grpc_version_string(void) { return "6.0.0-dev"; }
 
-const char* grpc_g_stands_for(void) { return "gloriosa"; }
+const char* grpc_g_stands_for(void) { return "gladiolus"; }

src/core/tsi/alts/handshaker/alts_handshaker_service_api_util.h

@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "third_party/nanopb/pb_decode.h"
-#include "third_party/nanopb/pb_encode.h"
+#include "pb_decode.h"
+#include "pb_encode.h"
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>

src/core/tsi/alts/handshaker/altscontext.pb.h

@@ -3,7 +3,7 @@
 
 #ifndef PB_GRPC_GCP_ALTSCONTEXT_PB_H_INCLUDED
 #define PB_GRPC_GCP_ALTSCONTEXT_PB_H_INCLUDED
-#include "third_party/nanopb/pb.h"
+#include "pb.h"
 #include "src/core/tsi/alts/handshaker/transport_security_common.pb.h"
 
 /* @@protoc_insertion_point(includes) */

src/core/tsi/alts/handshaker/handshaker.pb.h

@@ -3,7 +3,7 @@
 
 #ifndef PB_GRPC_GCP_HANDSHAKER_PB_H_INCLUDED
 #define PB_GRPC_GCP_HANDSHAKER_PB_H_INCLUDED
-#include "third_party/nanopb/pb.h"
+#include "pb.h"
 #include "src/core/tsi/alts/handshaker/transport_security_common.pb.h"
 
 /* @@protoc_insertion_point(includes) */

src/core/tsi/alts/handshaker/transport_security_common.pb.h

@@ -3,7 +3,7 @@
 
 #ifndef PB_GRPC_GCP_TRANSPORT_SECURITY_COMMON_PB_H_INCLUDED
 #define PB_GRPC_GCP_TRANSPORT_SECURITY_COMMON_PB_H_INCLUDED
-#include "third_party/nanopb/pb.h"
+#include "pb.h"
 /* @@protoc_insertion_point(includes) */
 #if PB_PROTO_HEADER_VERSION != 30
 #error Regenerate this file with the current version of nanopb generator.

src/core/tsi/alts/handshaker/transport_security_common_api.h

@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "third_party/nanopb/pb_decode.h"
-#include "third_party/nanopb/pb_encode.h"
+#include "pb_decode.h"
+#include "pb_encode.h"
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>

src/cpp/common/version_cc.cc

@@ -22,5 +22,5 @@
 #include <grpcpp/grpcpp.h>
 
 namespace grpc {
-grpc::string Version() { return "1.13.0-dev"; }
+grpc::string Version() { return "1.14.0-dev"; }
 }  // namespace grpc

src/cpp/server/health/default_health_check_service.cc

@@ -24,10 +24,10 @@
 #include <grpc/support/log.h>
 #include <grpcpp/impl/codegen/method_handler_impl.h>
 
+#include "pb_decode.h"
+#include "pb_encode.h"
 #include "src/cpp/server/health/default_health_check_service.h"
 #include "src/cpp/server/health/health.pb.h"
-#include "third_party/nanopb/pb_decode.h"
-#include "third_party/nanopb/pb_encode.h"
 
 namespace grpc {
 namespace {

src/cpp/server/health/health.pb.h

@@ -3,7 +3,7 @@
 
 #ifndef PB_GRPC_HEALTH_V1_HEALTH_PB_H_INCLUDED
 #define PB_GRPC_HEALTH_V1_HEALTH_PB_H_INCLUDED
-#include "third_party/nanopb/pb.h"
+#include "pb.h"
 /* @@protoc_insertion_point(includes) */
 #if PB_PROTO_HEADER_VERSION != 30
 #error Regenerate this file with the current version of nanopb generator.

src/cpp/server/server_builder.cc

@@ -24,6 +24,8 @@
 #include <grpcpp/resource_quota.h>
 #include <grpcpp/server.h>
 
+#include <utility>
+
 #include "src/core/lib/gpr/useful.h"
 #include "src/cpp/server/thread_pool_interface.h"
 
@@ -166,7 +168,7 @@ ServerBuilder& ServerBuilder::AddListeningPort(
     while (addr_uri[pos] == '/') ++pos;  // Skip slashes.
     addr = addr_uri.substr(pos);
   }
-  Port port = {addr, creds, selected_port};
+  Port port = {addr, std::move(creds), selected_port};
   ports_.push_back(port);
   return *this;
 }

src/cpp/server/server_cc.cc

@@ -219,7 +219,7 @@ class Server::SyncRequest final : public internal::CompletionQueueTag {
       }
     }
 
-    void Run(std::shared_ptr<GlobalCallbacks> global_callbacks) {
+    void Run(const std::shared_ptr<GlobalCallbacks>& global_callbacks) {
       ctx_.BeginCompletionOp(&call_);
       global_callbacks->PreSynchronousRequest(&ctx_);
       method_->handler()->RunHandler(internal::MethodHandler::HandlerParameter(
@@ -272,7 +272,7 @@ class Server::SyncRequestThreadManager : public ThreadManager {
         server_(server),
         server_cq_(server_cq),
         cq_timeout_msec_(cq_timeout_msec),
-        global_callbacks_(global_callbacks) {}
+        global_callbacks_(std::move(global_callbacks)) {}
 
   WorkStatus PollForWork(void** tag, bool* ok) override {
     *tag = nullptr;
@@ -378,7 +378,7 @@ Server::Server(
         sync_server_cqs,
     int min_pollers, int max_pollers, int sync_cq_timeout_msec)
     : max_receive_message_size_(max_receive_message_size),
-      sync_server_cqs_(sync_server_cqs),
+      sync_server_cqs_(std::move(sync_server_cqs)),
       started_(false),
       shutdown_(false),
       shutdown_notified_(false),

src/csharp/Grpc.Core/Version.csproj.include

@@ -1,7 +1,7 @@
 <!-- This file is generated -->
 <Project>
   <PropertyGroup>
-    <GrpcCsharpVersion>1.13.0-dev</GrpcCsharpVersion>
+    <GrpcCsharpVersion>1.14.0-dev</GrpcCsharpVersion>
     <GoogleProtobufVersion>3.5.1</GoogleProtobufVersion>
   </PropertyGroup>
 </Project>

src/csharp/Grpc.Core/VersionInfo.cs

@@ -33,11 +33,11 @@ namespace Grpc.Core
         /// <summary>
         /// Current <c>AssemblyFileVersion</c> of gRPC C# assemblies
         /// </summary>
-        public const string CurrentAssemblyFileVersion = "1.13.0.0";
+        public const string CurrentAssemblyFileVersion = "1.14.0.0";
 
         /// <summary>
         /// Current version of gRPC C#
         /// </summary>
-        public const string CurrentVersion = "1.13.0-dev";
+        public const string CurrentVersion = "1.14.0-dev";
     }
 }

src/csharp/build_packages_dotnetcli.bat

@@ -13,7 +13,7 @@
 @rem limitations under the License.
 
 @rem Current package versions
-set VERSION=1.13.0-dev
+set VERSION=1.14.0-dev
 
 @rem Adjust the location of nuget.exe
 set NUGET=C:\nuget\nuget.exe

src/csharp/build_packages_dotnetcli.sh

@@ -45,8 +45,8 @@ dotnet pack --configuration Release Grpc.Auth --output ../../../artifacts
 dotnet pack --configuration Release Grpc.HealthCheck --output ../../../artifacts
 dotnet pack --configuration Release Grpc.Reflection --output ../../../artifacts
 
-nuget pack Grpc.nuspec -Version "1.13.0-dev" -OutputDirectory ../../artifacts
-nuget pack Grpc.Core.NativeDebug.nuspec -Version "1.13.0-dev" -OutputDirectory ../../artifacts
-nuget pack Grpc.Tools.nuspec -Version "1.13.0-dev" -OutputDirectory ../../artifacts
+nuget pack Grpc.nuspec -Version "1.14.0-dev" -OutputDirectory ../../artifacts
+nuget pack Grpc.Core.NativeDebug.nuspec -Version "1.14.0-dev" -OutputDirectory ../../artifacts
+nuget pack Grpc.Tools.nuspec -Version "1.14.0-dev" -OutputDirectory ../../artifacts
 
 (cd ../../artifacts && zip csharp_nugets_dotnetcli.zip *.nupkg)

src/objective-c/!ProtoCompiler-gRPCPlugin.podspec

@@ -42,7 +42,7 @@ Pod::Spec.new do |s|
   # exclamation mark ensures that other "regular" pods will be able to find it as it'll be installed
   # before them.
   s.name     = '!ProtoCompiler-gRPCPlugin'
-  v = '1.13.0-dev'
+  v = '1.14.0-dev'
   s.version  = v
   s.summary  = 'The gRPC ProtoC plugin generates Objective-C files from .proto services.'
   s.description = <<-DESC

src/objective-c/GRPCClient/private/version.h

@@ -22,4 +22,4 @@
 // instead. This file can be regenerated from the template by running
 // `tools/buildgen/generate_projects.sh`.
 
-#define GRPC_OBJC_VERSION_STRING @"1.13.0-dev"
+#define GRPC_OBJC_VERSION_STRING @"1.14.0-dev"

src/objective-c/tests/version.h

@@ -22,5 +22,5 @@
 // instead. This file can be regenerated from the template by running
 // `tools/buildgen/generate_projects.sh`.
 
-#define GRPC_OBJC_VERSION_STRING @"1.13.0-dev"
+#define GRPC_OBJC_VERSION_STRING @"1.14.0-dev"
 #define GRPC_C_VERSION_STRING @"6.0.0-dev"

src/php/composer.json

@@ -2,7 +2,7 @@
   "name": "grpc/grpc-dev",
   "description": "gRPC library for PHP - for Developement use only",
   "license": "Apache-2.0",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "require": {
     "php": ">=5.5.0",
     "google/protobuf": "^v3.3.0"

src/php/ext/grpc/version.h

@@ -20,6 +20,6 @@
 #ifndef VERSION_H
 #define VERSION_H
 
-#define PHP_GRPC_VERSION "1.13.0dev"
+#define PHP_GRPC_VERSION "1.14.0dev"
 
 #endif /* VERSION_H */

src/python/grpcio/grpc/__init__.py

@@ -1572,13 +1572,15 @@ def channel_ready_future(channel):
 def insecure_channel(target, options=None):
     """Creates an insecure Channel to a server.
 
+    The returned Channel is thread-safe.
+
     Args:
       target: The server address
       options: An optional list of key-value pairs (channel args
         in gRPC Core runtime) to configure the channel.
 
     Returns:
-      A Channel object.
+      A Channel.
     """
     from grpc import _channel  # pylint: disable=cyclic-import
     return _channel.Channel(target, () if options is None else options, None)
@@ -1587,6 +1589,8 @@ def insecure_channel(target, options=None):
 def secure_channel(target, credentials, options=None):
     """Creates a secure Channel to a server.
 
+    The returned Channel is thread-safe.
+
     Args:
       target: The server address.
       credentials: A ChannelCredentials instance.
@@ -1594,7 +1598,7 @@ def secure_channel(target, credentials, options=None):
         in gRPC Core runtime) to configure the channel.
 
     Returns:
-      A Channel object.
+      A Channel.
     """
     from grpc import _channel  # pylint: disable=cyclic-import
     return _channel.Channel(target, () if options is None else options,

src/python/grpcio/grpc/_grpcio_metadata.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio/grpc/_grpcio_metadata.py.template`!!!
 
-__version__ = """1.13.0.dev0"""
+__version__ = """1.14.0.dev0"""

src/python/grpcio/grpc/_interceptor.py

@@ -75,10 +75,10 @@ def _unwrap_client_call_details(call_details, default_details):
     return method, timeout, metadata, credentials
 
 
-class _LocalFailure(grpc.RpcError, grpc.Future, grpc.Call):
+class _FailureOutcome(grpc.RpcError, grpc.Future, grpc.Call):
 
     def __init__(self, exception, traceback):
-        super(_LocalFailure, self).__init__()
+        super(_FailureOutcome, self).__init__()
         self._exception = exception
         self._traceback = traceback
 
@@ -134,6 +134,58 @@ class _LocalFailure(grpc.RpcError, grpc.Future, grpc.Call):
         raise self._exception
 
 
+class _UnaryOutcome(grpc.Call, grpc.Future):
+
+    def __init__(self, response, call):
+        self._response = response
+        self._call = call
+
+    def initial_metadata(self):
+        return self._call.initial_metadata()
+
+    def trailing_metadata(self):
+        return self._call.trailing_metadata()
+
+    def code(self):
+        return self._call.code()
+
+    def details(self):
+        return self._call.details()
+
+    def is_active(self):
+        return self._call.is_active()
+
+    def time_remaining(self):
+        return self._call.time_remaining()
+
+    def cancel(self):
+        return self._call.cancel()
+
+    def add_callback(self, callback):
+        return self._call.add_callback(callback)
+
+    def cancelled(self):
+        return False
+
+    def running(self):
+        return False
+
+    def done(self):
+        return True
+
+    def result(self, ignored_timeout=None):
+        return self._response
+
+    def exception(self, ignored_timeout=None):
+        return None
+
+    def traceback(self, ignored_timeout=None):
+        return None
+
+    def add_done_callback(self, fn):
+        fn(self)
+
+
 class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
 
     def __init__(self, thunk, method, interceptor):
@@ -142,23 +194,45 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
         self._interceptor = interceptor
 
     def __call__(self, request, timeout=None, metadata=None, credentials=None):
-        call_future = self.future(
+        response, ignored_call = self._with_call(
             request,
             timeout=timeout,
             metadata=metadata,
             credentials=credentials)
-        return call_future.result()
+        return response
+
+    def _with_call(self, request, timeout=None, metadata=None,
+                   credentials=None):
+        client_call_details = _ClientCallDetails(self._method, timeout,
+                                                 metadata, credentials)
+
+        def continuation(new_details, request):
+            new_method, new_timeout, new_metadata, new_credentials = (
+                _unwrap_client_call_details(new_details, client_call_details))
+            try:
+                response, call = self._thunk(new_method).with_call(
+                    request,
+                    timeout=new_timeout,
+                    metadata=new_metadata,
+                    credentials=new_credentials)
+                return _UnaryOutcome(response, call)
+            except grpc.RpcError:
+                raise
+            except Exception as exception:  # pylint:disable=broad-except
+                return _FailureOutcome(exception, sys.exc_info()[2])
+
+        call = self._interceptor.intercept_unary_unary(
+            continuation, client_call_details, request)
+        return call.result(), call
 
     def with_call(self, request, timeout=None, metadata=None, credentials=None):
-        call_future = self.future(
+        return self._with_call(
             request,
             timeout=timeout,
             metadata=metadata,
             credentials=credentials)
-        return call_future.result(), call_future
 
     def future(self, request, timeout=None, metadata=None, credentials=None):
-
         client_call_details = _ClientCallDetails(self._method, timeout,
                                                  metadata, credentials)
 
@@ -175,7 +249,7 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
             return self._interceptor.intercept_unary_unary(
                 continuation, client_call_details, request)
         except Exception as exception:  # pylint:disable=broad-except
-            return _LocalFailure(exception, sys.exc_info()[2])
+            return _FailureOutcome(exception, sys.exc_info()[2])
 
 
 class _UnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
@@ -202,7 +276,7 @@ class _UnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
             return self._interceptor.intercept_unary_stream(
                 continuation, client_call_details, request)
         except Exception as exception:  # pylint:disable=broad-except
-            return _LocalFailure(exception, sys.exc_info()[2])
+            return _FailureOutcome(exception, sys.exc_info()[2])
 
 
 class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
@@ -217,24 +291,50 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
                  timeout=None,
                  metadata=None,
                  credentials=None):
-        call_future = self.future(
+        response, ignored_call = self._with_call(
             request_iterator,
             timeout=timeout,
             metadata=metadata,
             credentials=credentials)
-        return call_future.result()
+        return response
+
+    def _with_call(self,
+                   request_iterator,
+                   timeout=None,
+                   metadata=None,
+                   credentials=None):
+        client_call_details = _ClientCallDetails(self._method, timeout,
+                                                 metadata, credentials)
+
+        def continuation(new_details, request_iterator):
+            new_method, new_timeout, new_metadata, new_credentials = (
+                _unwrap_client_call_details(new_details, client_call_details))
+            try:
+                response, call = self._thunk(new_method).with_call(
+                    request_iterator,
+                    timeout=new_timeout,
+                    metadata=new_metadata,
+                    credentials=new_credentials)
+                return _UnaryOutcome(response, call)
+            except grpc.RpcError:
+                raise
+            except Exception as exception:  # pylint:disable=broad-except
+                return _FailureOutcome(exception, sys.exc_info()[2])
+
+        call = self._interceptor.intercept_stream_unary(
+            continuation, client_call_details, request_iterator)
+        return call.result(), call
 
     def with_call(self,
                   request_iterator,
                   timeout=None,
                   metadata=None,
                   credentials=None):
-        call_future = self.future(
+        return self._with_call(
             request_iterator,
             timeout=timeout,
             metadata=metadata,
             credentials=credentials)
-        return call_future.result(), call_future
 
     def future(self,
                request_iterator,
@@ -257,7 +357,7 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
             return self._interceptor.intercept_stream_unary(
                 continuation, client_call_details, request_iterator)
         except Exception as exception:  # pylint:disable=broad-except
-            return _LocalFailure(exception, sys.exc_info()[2])
+            return _FailureOutcome(exception, sys.exc_info()[2])
 
 
 class _StreamStreamMultiCallable(grpc.StreamStreamMultiCallable):
@@ -288,7 +388,7 @@ class _StreamStreamMultiCallable(grpc.StreamStreamMultiCallable):
             return self._interceptor.intercept_stream_stream(
                 continuation, client_call_details, request_iterator)
         except Exception as exception:  # pylint:disable=broad-except
-            return _LocalFailure(exception, sys.exc_info()[2])
+            return _FailureOutcome(exception, sys.exc_info()[2])
 
 
 class _Channel(grpc.Channel):

src/python/grpcio/grpc_version.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio/grpc_version.py.template`!!!
 
-VERSION = '1.13.0.dev0'
+VERSION = '1.14.0.dev0'

src/python/grpcio_health_checking/grpc_version.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio_health_checking/grpc_version.py.template`!!!
 
-VERSION = '1.13.0.dev0'
+VERSION = '1.14.0.dev0'

src/python/grpcio_reflection/grpc_version.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio_reflection/grpc_version.py.template`!!!
 
-VERSION = '1.13.0.dev0'
+VERSION = '1.14.0.dev0'

src/python/grpcio_testing/grpc_version.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio_testing/grpc_version.py.template`!!!
 
-VERSION = '1.13.0.dev0'
+VERSION = '1.14.0.dev0'

src/python/grpcio_tests/grpc_version.py

@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio_tests/grpc_version.py.template`!!!
 
-VERSION = '1.13.0.dev0'
+VERSION = '1.14.0.dev0'

src/ruby/lib/grpc/generic/active_call.rb

@@ -116,9 +116,10 @@ module GRPC
 
     # Sends the initial metadata that has yet to be sent.
     # Does nothing if metadata has already been sent for this call.
-    def send_initial_metadata
+    def send_initial_metadata(new_metadata = {})
       @send_initial_md_mutex.synchronize do
         return if @metadata_sent
+        @metadata_to_send.merge!(new_metadata)
         @metadata_tag = ActiveCall.client_invoke(@call, @metadata_to_send)
         @metadata_sent = true
       end
@@ -388,7 +389,7 @@ module GRPC
     def client_streamer(requests, metadata: {})
       raise_error_if_already_executed
       begin
-        merge_metadata_and_send_if_not_already_sent(metadata)
+        send_initial_metadata(metadata)
         requests.each { |r| @call.run_batch(SEND_MESSAGE => @marshal.call(r)) }
       rescue GRPC::Core::CallError => e
         receive_and_check_status # check for Cancelled
@@ -490,7 +491,7 @@ module GRPC
       raise_error_if_already_executed
       # Metadata might have already been sent if this is an operation view
       begin
-        merge_metadata_and_send_if_not_already_sent(metadata)
+        send_initial_metadata(metadata)
       rescue GRPC::Core::CallError => e
         batch_result = @call.run_batch(RECV_STATUS_ON_CLIENT => nil)
         set_input_stream_done
@@ -571,15 +572,6 @@ module GRPC
       end
     end
 
-    def merge_metadata_and_send_if_not_already_sent(new_metadata = {})
-      @send_initial_md_mutex.synchronize do
-        return if @metadata_sent
-        @metadata_to_send.merge!(new_metadata)
-        @call.run_batch(SEND_INITIAL_METADATA => @metadata_to_send)
-        @metadata_sent = true
-      end
-    end
-
     def attach_peer_cert(peer_cert)
       @peer_cert = peer_cert
     end

src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.13.0.dev'
+  VERSION = '1.14.0.dev'
 end

src/ruby/tools/version.rb

@@ -14,6 +14,6 @@
 
 module GRPC
   module Tools
-    VERSION = '1.13.0.dev'
+    VERSION = '1.14.0.dev'
   end
 end

templates/CMakeLists.txt.template

@@ -168,6 +168,7 @@
   include(cmake/gflags.cmake)
   include(cmake/benchmark.cmake)
   include(cmake/address_sorting.cmake)
+  include(cmake/nanopb.cmake)
 
   if(NOT MSVC)
     set(CMAKE_C_FLAGS   "<%text>${CMAKE_C_FLAGS}</%text> -std=c99")
@@ -383,6 +384,7 @@
     PRIVATE <%text>${_gRPC_CARES_INCLUDE_DIR}</%text>
     PRIVATE <%text>${_gRPC_GFLAGS_INCLUDE_DIR}</%text>
     PRIVATE <%text>${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}</%text>
+    PRIVATE <%text>${_gRPC_NANOPB_INCLUDE_DIR}</%text>
   % if lib.build in ['test', 'private'] and lib.language == 'c++':
     PRIVATE third_party/googletest/googletest/include
     PRIVATE third_party/googletest/googletest
@@ -464,6 +466,7 @@
     PRIVATE <%text>${_gRPC_CARES_INCLUDE_DIR}</%text>
     PRIVATE <%text>${_gRPC_GFLAGS_INCLUDE_DIR}</%text>
     PRIVATE <%text>${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}</%text>
+    PRIVATE <%text>${_gRPC_NANOPB_INCLUDE_DIR}</%text>
   % if tgt.build in ['test', 'private'] and tgt.language == 'c++':
     PRIVATE third_party/googletest/googletest/include
     PRIVATE third_party/googletest/googletest

templates/Makefile.template

@@ -221,8 +221,6 @@
   %  endif
   % endfor
 
-  DEFINES += PB_FIELD_16BIT
-
   CPPFLAGS += $(CPPFLAGS_$(CONFIG))
   CFLAGS += $(CFLAGS_$(CONFIG))
   CXXFLAGS += $(CXXFLAGS_$(CONFIG))