Merge remote-tracking branch 'upstream/master' into server_connection_timeout

.clang_complete

@@ -10,3 +10,8 @@
 -Ithird_party/zlib
 -Ithird_party/protobuf/src
 -Ithird_party/abseil-cpp
+-Ithird_party/cares/cares
+-Ithird_party/cares
+-Ithird_party/googletest/googletest/include
+-Ithird_party/googletest/googlemock/include
+

BUILD

@@ -33,6 +33,11 @@ load(
     "grpc_generate_one_off_targets",
 )
 
+config_setting(
+    name = "grpc_no_ares",
+    values = {"define": "grpc_no_ares=true"},
+)
+
 # This should be updated along with build.yaml
 g_stands_for = "generous"
 

CMakeLists.txt

@@ -462,6 +462,9 @@ endif()
 if(_gRPC_PLATFORM_LINUX)
 add_dependencies(buildtests_c handshake_server)
 endif()
+if(_gRPC_PLATFORM_LINUX)
+add_dependencies(buildtests_c handshake_server_with_readahead_handshaker)
+endif()
 add_dependencies(buildtests_c hpack_parser_test)
 add_dependencies(buildtests_c hpack_table_test)
 add_dependencies(buildtests_c http_parser_test)
@@ -675,6 +678,7 @@ endif()
 add_dependencies(buildtests_cxx channel_arguments_test)
 add_dependencies(buildtests_cxx channel_filter_test)
 add_dependencies(buildtests_cxx cli_call_test)
+add_dependencies(buildtests_cxx client_channel_stress_test)
 if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
 add_dependencies(buildtests_cxx client_crash_test)
 endif()
@@ -7236,6 +7240,7 @@ if(_gRPC_PLATFORM_LINUX)
 
 add_executable(handshake_server
   test/core/handshake/server_ssl.cc
+  test/core/handshake/server_ssl_common.cc
 )
 
 
@@ -7262,6 +7267,40 @@ target_link_libraries(handshake_server
   gpr
 )
 
+endif()
+endif (gRPC_BUILD_TESTS)
+if (gRPC_BUILD_TESTS)
+if(_gRPC_PLATFORM_LINUX)
+
+add_executable(handshake_server_with_readahead_handshaker
+  test/core/handshake/readahead_handshaker_server_ssl.cc
+  test/core/handshake/server_ssl_common.cc
+)
+
+
+target_include_directories(handshake_server_with_readahead_handshaker
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+  PRIVATE ${BORINGSSL_ROOT_DIR}/include
+  PRIVATE ${PROTOBUF_ROOT_DIR}/src
+  PRIVATE ${BENCHMARK_ROOT_DIR}/include
+  PRIVATE ${ZLIB_ROOT_DIR}
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/zlib
+  PRIVATE ${CARES_INCLUDE_DIR}
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/cares/cares
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags/include
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/third_party/abseil-cpp
+)
+
+target_link_libraries(handshake_server_with_readahead_handshaker
+  ${_gRPC_SSL_LIBRARIES}
+  ${_gRPC_ALLTARGETS_LIBRARIES}
+  grpc_test_util
+  grpc
+  gpr_test_util
+  gpr
+)
+
 endif()
 endif (gRPC_BUILD_TESTS)
 if (gRPC_BUILD_TESTS)
@@ -10028,6 +10067,54 @@ target_link_libraries(cli_call_test
   ${_gRPC_GFLAGS_LIBRARIES}
 )
 
+endif (gRPC_BUILD_TESTS)
+if (gRPC_BUILD_TESTS)
+
+add_executable(client_channel_stress_test
+  ${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/lb/v1/load_balancer.pb.cc
+  ${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/lb/v1/load_balancer.grpc.pb.cc
+  ${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/lb/v1/load_balancer.pb.h
+  ${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/lb/v1/load_balancer.grpc.pb.h
+  test/cpp/client/client_channel_stress_test.cc
+  third_party/googletest/googletest/src/gtest-all.cc
+  third_party/googletest/googlemock/src/gmock-all.cc
+)
+
+protobuf_generate_grpc_cpp(
+  src/proto/grpc/lb/v1/load_balancer.proto
+)
+
+target_include_directories(client_channel_stress_test
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+  PRIVATE ${BORINGSSL_ROOT_DIR}/include
+  PRIVATE ${PROTOBUF_ROOT_DIR}/src
+  PRIVATE ${BENCHMARK_ROOT_DIR}/include
+  PRIVATE ${ZLIB_ROOT_DIR}
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/zlib
+  PRIVATE ${CARES_INCLUDE_DIR}
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/cares/cares
+  PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags/include
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/third_party/abseil-cpp
+  PRIVATE third_party/googletest/googletest/include
+  PRIVATE third_party/googletest/googletest
+  PRIVATE third_party/googletest/googlemock/include
+  PRIVATE third_party/googletest/googlemock
+  PRIVATE ${_gRPC_PROTO_GENS_DIR}
+)
+
+target_link_libraries(client_channel_stress_test
+  ${_gRPC_PROTOBUF_LIBRARIES}
+  ${_gRPC_ALLTARGETS_LIBRARIES}
+  grpc++_test_util
+  grpc_test_util
+  grpc++
+  grpc
+  gpr_test_util
+  gpr
+  ${_gRPC_GFLAGS_LIBRARIES}
+)
+
 endif (gRPC_BUILD_TESTS)
 if (gRPC_BUILD_TESTS)
 if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)

Makefile

@@ -1019,6 +1019,7 @@ grpc_ssl_credentials_test: $(BINDIR)/$(CONFIG)/grpc_ssl_credentials_test
 grpc_verify_jwt: $(BINDIR)/$(CONFIG)/grpc_verify_jwt
 handshake_client: $(BINDIR)/$(CONFIG)/handshake_client
 handshake_server: $(BINDIR)/$(CONFIG)/handshake_server
+handshake_server_with_readahead_handshaker: $(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker
 hpack_parser_fuzzer_test: $(BINDIR)/$(CONFIG)/hpack_parser_fuzzer_test
 hpack_parser_test: $(BINDIR)/$(CONFIG)/hpack_parser_test
 hpack_table_test: $(BINDIR)/$(CONFIG)/hpack_table_test
@@ -1113,6 +1114,7 @@ bm_pollset: $(BINDIR)/$(CONFIG)/bm_pollset
 channel_arguments_test: $(BINDIR)/$(CONFIG)/channel_arguments_test
 channel_filter_test: $(BINDIR)/$(CONFIG)/channel_filter_test
 cli_call_test: $(BINDIR)/$(CONFIG)/cli_call_test
+client_channel_stress_test: $(BINDIR)/$(CONFIG)/client_channel_stress_test
 client_crash_test: $(BINDIR)/$(CONFIG)/client_crash_test
 client_crash_test_server: $(BINDIR)/$(CONFIG)/client_crash_test_server
 client_lb_end2end_test: $(BINDIR)/$(CONFIG)/client_lb_end2end_test
@@ -1408,6 +1410,7 @@ buildtests_c: privatelibs_c \
   $(BINDIR)/$(CONFIG)/grpc_ssl_credentials_test \
   $(BINDIR)/$(CONFIG)/handshake_client \
   $(BINDIR)/$(CONFIG)/handshake_server \
+  $(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker \
   $(BINDIR)/$(CONFIG)/hpack_parser_test \
   $(BINDIR)/$(CONFIG)/hpack_table_test \
   $(BINDIR)/$(CONFIG)/http_parser_test \
@@ -1553,6 +1556,7 @@ buildtests_cxx: privatelibs_cxx \
   $(BINDIR)/$(CONFIG)/channel_arguments_test \
   $(BINDIR)/$(CONFIG)/channel_filter_test \
   $(BINDIR)/$(CONFIG)/cli_call_test \
+  $(BINDIR)/$(CONFIG)/client_channel_stress_test \
   $(BINDIR)/$(CONFIG)/client_crash_test \
   $(BINDIR)/$(CONFIG)/client_crash_test_server \
   $(BINDIR)/$(CONFIG)/client_lb_end2end_test \
@@ -1678,6 +1682,7 @@ buildtests_cxx: privatelibs_cxx \
   $(BINDIR)/$(CONFIG)/channel_arguments_test \
   $(BINDIR)/$(CONFIG)/channel_filter_test \
   $(BINDIR)/$(CONFIG)/cli_call_test \
+  $(BINDIR)/$(CONFIG)/client_channel_stress_test \
   $(BINDIR)/$(CONFIG)/client_crash_test \
   $(BINDIR)/$(CONFIG)/client_crash_test_server \
   $(BINDIR)/$(CONFIG)/client_lb_end2end_test \
@@ -1876,6 +1881,8 @@ test_c: buildtests_c
 	$(Q) $(BINDIR)/$(CONFIG)/handshake_client || ( echo test handshake_client failed ; exit 1 )
 	$(E) "[RUN]     Testing handshake_server"
 	$(Q) $(BINDIR)/$(CONFIG)/handshake_server || ( echo test handshake_server failed ; exit 1 )
+	$(E) "[RUN]     Testing handshake_server_with_readahead_handshaker"
+	$(Q) $(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker || ( echo test handshake_server_with_readahead_handshaker failed ; exit 1 )
 	$(E) "[RUN]     Testing hpack_parser_test"
 	$(Q) $(BINDIR)/$(CONFIG)/hpack_parser_test || ( echo test hpack_parser_test failed ; exit 1 )
 	$(E) "[RUN]     Testing hpack_table_test"
@@ -2060,6 +2067,8 @@ test_cxx: buildtests_cxx
 	$(Q) $(BINDIR)/$(CONFIG)/channel_filter_test || ( echo test channel_filter_test failed ; exit 1 )
 	$(E) "[RUN]     Testing cli_call_test"
 	$(Q) $(BINDIR)/$(CONFIG)/cli_call_test || ( echo test cli_call_test failed ; exit 1 )
+	$(E) "[RUN]     Testing client_channel_stress_test"
+	$(Q) $(BINDIR)/$(CONFIG)/client_channel_stress_test || ( echo test client_channel_stress_test failed ; exit 1 )
 	$(E) "[RUN]     Testing client_crash_test"
 	$(Q) $(BINDIR)/$(CONFIG)/client_crash_test || ( echo test client_crash_test failed ; exit 1 )
 	$(E) "[RUN]     Testing client_lb_end2end_test"
@@ -2499,12 +2508,12 @@ $(GENDIR)/src/proto/grpc/testing/services.pb.cc: protoc_dep_error
 $(GENDIR)/src/proto/grpc/testing/services.grpc.pb.cc: protoc_dep_error
 else
 
-$(GENDIR)/src/proto/grpc/testing/services.pb.cc: src/proto/grpc/testing/services.proto $(PROTOBUF_DEP) $(PROTOC_PLUGINS) $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/control.pb.cc $(GENDIR)/src/proto/grpc/testing/stats.pb.cc
+$(GENDIR)/src/proto/grpc/testing/services.pb.cc: src/proto/grpc/testing/services.proto $(PROTOBUF_DEP) $(PROTOC_PLUGINS) $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/control.pb.cc
 	$(E) "[PROTOC]  Generating protobuf CC file from $<"
 	$(Q) mkdir -p `dirname $@`
 	$(Q) $(PROTOC) -Ithird_party/protobuf/src -I. --cpp_out=$(GENDIR) $<
 
-$(GENDIR)/src/proto/grpc/testing/services.grpc.pb.cc: src/proto/grpc/testing/services.proto $(GENDIR)/src/proto/grpc/testing/services.pb.cc $(PROTOBUF_DEP) $(PROTOC_PLUGINS) $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/control.pb.cc $(GENDIR)/src/proto/grpc/testing/control.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/stats.pb.cc $(GENDIR)/src/proto/grpc/testing/stats.grpc.pb.cc
+$(GENDIR)/src/proto/grpc/testing/services.grpc.pb.cc: src/proto/grpc/testing/services.proto $(GENDIR)/src/proto/grpc/testing/services.pb.cc $(PROTOBUF_DEP) $(PROTOC_PLUGINS) $(GENDIR)/src/proto/grpc/testing/messages.pb.cc $(GENDIR)/src/proto/grpc/testing/messages.grpc.pb.cc $(GENDIR)/src/proto/grpc/testing/control.pb.cc $(GENDIR)/src/proto/grpc/testing/control.grpc.pb.cc
 	$(E) "[GRPC]    Generating gRPC's protobuf service CC file from $<"
 	$(Q) mkdir -p `dirname $@`
 	$(Q) $(PROTOC) -Ithird_party/protobuf/src -I. --grpc_out=$(GENDIR) --plugin=protoc-gen-grpc=$(PROTOC_PLUGINS_DIR)/grpc_cpp_plugin$(EXECUTABLE_SUFFIX) $<
@@ -11040,6 +11049,7 @@ endif
 
 HANDSHAKE_SERVER_SRC = \
     test/core/handshake/server_ssl.cc \
+    test/core/handshake/server_ssl_common.cc \
 
 HANDSHAKE_SERVER_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(HANDSHAKE_SERVER_SRC))))
 ifeq ($(NO_SECURE),true)
@@ -11061,6 +11071,8 @@ endif
 
 $(OBJDIR)/$(CONFIG)/test/core/handshake/server_ssl.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
 
+$(OBJDIR)/$(CONFIG)/test/core/handshake/server_ssl_common.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
 deps_handshake_server: $(HANDSHAKE_SERVER_OBJS:.o=.dep)
 
 ifneq ($(NO_SECURE),true)
@@ -11070,6 +11082,41 @@ endif
 endif
 
 
+HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_SRC = \
+    test/core/handshake/readahead_handshaker_server_ssl.cc \
+    test/core/handshake/server_ssl_common.cc \
+
+HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_SRC))))
+ifeq ($(NO_SECURE),true)
+
+# You can't build secure targets if you don't have OpenSSL.
+
+$(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker: openssl_dep_error
+
+else
+
+
+
+$(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker: $(HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+	$(E) "[LD]      Linking $@"
+	$(Q) mkdir -p `dirname $@`
+	$(Q) $(LD) $(LDFLAGS) $(HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBS) $(LDLIBS_SECURE) -o $(BINDIR)/$(CONFIG)/handshake_server_with_readahead_handshaker
+
+endif
+
+$(OBJDIR)/$(CONFIG)/test/core/handshake/readahead_handshaker_server_ssl.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
+$(OBJDIR)/$(CONFIG)/test/core/handshake/server_ssl_common.o:  $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
+deps_handshake_server_with_readahead_handshaker: $(HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_OBJS:.o=.dep)
+
+ifneq ($(NO_SECURE),true)
+ifneq ($(NO_DEPS),true)
+-include $(HANDSHAKE_SERVER_WITH_READAHEAD_HANDSHAKER_OBJS:.o=.dep)
+endif
+endif
+
+
 HPACK_PARSER_FUZZER_TEST_SRC = \
     test/core/transport/chttp2/hpack_parser_fuzzer_test.cc \
 
@@ -14326,6 +14373,53 @@ endif
 endif
 
 
+CLIENT_CHANNEL_STRESS_TEST_SRC = \
+    $(GENDIR)/src/proto/grpc/lb/v1/load_balancer.pb.cc $(GENDIR)/src/proto/grpc/lb/v1/load_balancer.grpc.pb.cc \
+    test/cpp/client/client_channel_stress_test.cc \
+
+CLIENT_CHANNEL_STRESS_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(CLIENT_CHANNEL_STRESS_TEST_SRC))))
+ifeq ($(NO_SECURE),true)
+
+# You can't build secure targets if you don't have OpenSSL.
+
+$(BINDIR)/$(CONFIG)/client_channel_stress_test: openssl_dep_error
+
+else
+
+
+
+
+ifeq ($(NO_PROTOBUF),true)
+
+# You can't build the protoc plugins or protobuf-enabled targets if you don't have protobuf 3.0.0+.
+
+$(BINDIR)/$(CONFIG)/client_channel_stress_test: protobuf_dep_error
+
+else
+
+$(BINDIR)/$(CONFIG)/client_channel_stress_test: $(PROTOBUF_DEP) $(CLIENT_CHANNEL_STRESS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+	$(E) "[LD]      Linking $@"
+	$(Q) mkdir -p `dirname $@`
+	$(Q) $(LDXX) $(LDFLAGS) $(CLIENT_CHANNEL_STRESS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/client_channel_stress_test
+
+endif
+
+endif
+
+$(OBJDIR)/$(CONFIG)/src/proto/grpc/lb/v1/load_balancer.o:  $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
+$(OBJDIR)/$(CONFIG)/test/cpp/client/client_channel_stress_test.o:  $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a
+
+deps_client_channel_stress_test: $(CLIENT_CHANNEL_STRESS_TEST_OBJS:.o=.dep)
+
+ifneq ($(NO_SECURE),true)
+ifneq ($(NO_DEPS),true)
+-include $(CLIENT_CHANNEL_STRESS_TEST_OBJS:.o=.dep)
+endif
+endif
+$(OBJDIR)/$(CONFIG)/test/cpp/client/client_channel_stress_test.o: $(GENDIR)/src/proto/grpc/lb/v1/load_balancer.pb.cc $(GENDIR)/src/proto/grpc/lb/v1/load_balancer.grpc.pb.cc
+
+
 CLIENT_CRASH_TEST_SRC = \
     test/cpp/end2end/client_crash_test.cc \
 

bazel/grpc_build_system.bzl

@@ -33,6 +33,10 @@ def grpc_cc_library(name, srcs = [], public_hdrs = [], hdrs = [],
   native.cc_library(
     name = name,
     srcs = srcs,
+    defines = select({
+        "//:grpc_no_ares": ["GRPC_ARES=0"],
+	"//conditions:default": [],
+    }),
     hdrs = hdrs + public_hdrs,
     deps = deps + ["//external:" + dep for dep in external_deps],
     copts = copts,

build.yaml

@@ -2511,8 +2511,29 @@ targets:
 - name: handshake_server
   build: test
   language: c
+  headers:
+  - test/core/handshake/server_ssl_common.h
   src:
   - test/core/handshake/server_ssl.cc
+  - test/core/handshake/server_ssl_common.cc
+  deps:
+  - grpc_test_util
+  - grpc
+  - gpr_test_util
+  - gpr
+  exclude_iomgrs:
+  - uv
+  platforms:
+  - linux
+  secure: true
+- name: handshake_server_with_readahead_handshaker
+  build: test
+  language: c
+  headers:
+  - test/core/handshake/server_ssl_common.h
+  src:
+  - test/core/handshake/readahead_handshaker_server_ssl.cc
+  - test/core/handshake/server_ssl_common.cc
   deps:
   - grpc_test_util
   - grpc
@@ -3475,8 +3496,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3498,8 +3517,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3521,8 +3538,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3544,8 +3559,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3566,8 +3579,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3588,8 +3599,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3610,8 +3619,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=4
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3632,8 +3639,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3657,8 +3662,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   excluded_poll_engines:
@@ -3685,8 +3688,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   excluded_poll_engines:
@@ -3712,8 +3713,6 @@ targets:
   - gpr_test_util
   - gpr
   - grpc++_test_config
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   exclude_configs:
@@ -3742,8 +3741,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   excluded_poll_engines:
@@ -3768,8 +3765,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3791,8 +3786,6 @@ targets:
   - grpc_unsecure
   - gpr_test_util
   - gpr
-  args:
-  - --benchmark_min_time=0
   benchmark: true
   defaults: benchmark
   platforms:
@@ -3835,6 +3828,20 @@ targets:
   - grpc
   - gpr_test_util
   - gpr
+- name: client_channel_stress_test
+  gtest: false
+  build: test
+  language: c++
+  src:
+  - src/proto/grpc/lb/v1/load_balancer.proto
+  - test/cpp/client/client_channel_stress_test.cc
+  deps:
+  - grpc++_test_util
+  - grpc_test_util
+  - grpc++
+  - grpc
+  - gpr_test_util
+  - gpr
 - name: client_crash_test
   gtest: true
   cpu_cost: 0.1

doc/connectivity-semantics-and-api.md

@@ -115,8 +115,14 @@ Channel State API
 -----------------
 
 All gRPC libraries will expose a channel-level API method to poll the current
-state of a channel. In C++, this method is called GetCurrentState and returns
-an enum for one of the five legal states.
+state of a channel. In C++, this method is called GetState and returns an enum
+for one of the five legal states. It also accepts a boolean `try_to_connect` to
+transition to CONNECTING if the channel is currently IDLE. The boolean should
+act as if an RPC occurred, so it should also reset IDLE_TIMEOUT.
+
+```cpp
+grpc_connectivity_state GetState(bool try_to_connect);
+```
 
 All libraries should also expose an API that enables the application (user of
 the gRPC API) to be notified when the channel state changes. Since state
@@ -127,11 +133,11 @@ the user to poll the channel for the current state.
 The synchronous version of this API is:
 
 ```cpp
-bool WaitForStateChange(gpr_timespec deadline, ChannelState source_state);
+bool WaitForStateChange(grpc_connectivity_state source_state, gpr_timespec deadline);
 ```
 
-which returns true when the state changes to something other than the
-source_state and false if the deadline expires. Asynchronous and futures based
+which returns `true` when the state is something other than the
+`source_state` and `false` if the deadline expires. Asynchronous- and futures-based
 APIs should have a corresponding method that allows the application to be
 notified when the state of a channel changes.
 

include/grpc++/impl/codegen/completion_queue.h

@@ -65,6 +65,7 @@ class CompletionQueue;
 class Server;
 class ServerBuilder;
 class ServerContext;
+class ServerInterface;
 
 namespace internal {
 class CompletionQueueTag;
@@ -187,21 +188,6 @@ class CompletionQueue : private GrpcLibraryCodegen {
   /// owership is performed.
   grpc_completion_queue* cq() { return cq_; }
 
-  /// Manage state of avalanching operations : completion queue tags that
-  /// trigger other completion queue operations. The underlying core completion
-  /// queue should not really shutdown until all avalanching operations have
-  /// been finalized. Note that we maintain the requirement that an avalanche
-  /// registration must take place before CQ shutdown (which must be maintained
-  /// elsehwere)
-  void InitialAvalanching() {
-    gpr_atm_rel_store(&avalanches_in_flight_, static_cast<gpr_atm>(1));
-  }
-  void RegisterAvalanching() {
-    gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
-                                 static_cast<gpr_atm>(1));
-  }
-  void CompleteAvalanching();
-
  protected:
   /// Private constructor of CompletionQueue only visible to friend classes
   CompletionQueue(const grpc_completion_queue_attributes& attributes) {
@@ -238,6 +224,7 @@ class CompletionQueue : private GrpcLibraryCodegen {
   friend class ::grpc::internal::UnknownMethodHandler;
   friend class ::grpc::Server;
   friend class ::grpc::ServerContext;
+  friend class ::grpc::ServerInterface;
   template <class InputMessage, class OutputMessage>
   friend class ::grpc::internal::BlockingUnaryCallImpl;
 
@@ -309,6 +296,21 @@ class CompletionQueue : private GrpcLibraryCodegen {
     GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
   }
 
+  /// Manage state of avalanching operations : completion queue tags that
+  /// trigger other completion queue operations. The underlying core completion
+  /// queue should not really shutdown until all avalanching operations have
+  /// been finalized. Note that we maintain the requirement that an avalanche
+  /// registration must take place before CQ shutdown (which must be maintained
+  /// elsehwere)
+  void InitialAvalanching() {
+    gpr_atm_rel_store(&avalanches_in_flight_, static_cast<gpr_atm>(1));
+  }
+  void RegisterAvalanching() {
+    gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
+                                 static_cast<gpr_atm>(1));
+  }
+  void CompleteAvalanching();
+
   grpc_completion_queue* cq_;  // owned
 
   gpr_atm avalanches_in_flight_;

include/grpc++/impl/codegen/proto_utils.h

@@ -41,8 +41,11 @@ const int kGrpcBufferWriterMaxBufferLength = 1024 * 1024;
 
 class GrpcBufferWriter : public ::grpc::protobuf::io::ZeroCopyOutputStream {
  public:
-  explicit GrpcBufferWriter(grpc_byte_buffer** bp, int block_size)
-      : block_size_(block_size), byte_count_(0), have_backup_(false) {
+  GrpcBufferWriter(grpc_byte_buffer** bp, int block_size, int total_size)
+      : block_size_(block_size),
+        total_size_(total_size),
+        byte_count_(0),
+        have_backup_(false) {
     *bp = g_core_codegen_interface->grpc_raw_byte_buffer_create(NULL, 0);
     slice_buffer_ = &(*bp)->data.raw.slice_buffer;
   }
@@ -54,11 +57,20 @@ class GrpcBufferWriter : public ::grpc::protobuf::io::ZeroCopyOutputStream {
   }
 
   bool Next(void** data, int* size) override {
+    // Protobuf should not ask for more memory than total_size_.
+    GPR_CODEGEN_ASSERT(byte_count_ < total_size_);
     if (have_backup_) {
       slice_ = backup_slice_;
       have_backup_ = false;
     } else {
-      slice_ = g_core_codegen_interface->grpc_slice_malloc(block_size_);
+      // When less than a whole block is needed, only allocate that much.
+      // But make sure the allocated slice is not inlined.
+      size_t remain = total_size_ - byte_count_ > block_size_
+                          ? block_size_
+                          : total_size_ - byte_count_;
+      slice_ = g_core_codegen_interface->grpc_slice_malloc(
+          remain > GRPC_SLICE_INLINED_SIZE ? remain
+                                           : GRPC_SLICE_INLINED_SIZE + 1);
     }
     *data = GRPC_SLICE_START_PTR(slice_);
     // On win x64, int is only 32bit
@@ -70,7 +82,7 @@ class GrpcBufferWriter : public ::grpc::protobuf::io::ZeroCopyOutputStream {
 
   void BackUp(int count) override {
     g_core_codegen_interface->grpc_slice_buffer_pop(slice_buffer_);
-    if (count == block_size_) {
+    if ((size_t)count == GRPC_SLICE_LENGTH(slice_)) {
       backup_slice_ = slice_;
     } else {
       backup_slice_ = g_core_codegen_interface->grpc_slice_split_tail(
@@ -90,6 +102,7 @@ class GrpcBufferWriter : public ::grpc::protobuf::io::ZeroCopyOutputStream {
  protected:
   friend class GrpcBufferWriterPeer;
   const int block_size_;
+  const int total_size_;
   int64_t byte_count_;
   grpc_slice_buffer* slice_buffer_;
   bool have_backup_;
@@ -175,20 +188,20 @@ Status GenericSerialize(const grpc::protobuf::Message& msg,
       "BufferWriter must be a subclass of io::ZeroCopyOutputStream");
   *own_buffer = true;
   int byte_size = msg.ByteSize();
-  if (byte_size <= kGrpcBufferWriterMaxBufferLength) {
+  if ((size_t)byte_size <= GRPC_SLICE_INLINED_SIZE) {
     grpc_slice slice = g_core_codegen_interface->grpc_slice_malloc(byte_size);
     GPR_CODEGEN_ASSERT(
         GRPC_SLICE_END_PTR(slice) ==
         msg.SerializeWithCachedSizesToArray(GRPC_SLICE_START_PTR(slice)));
     *bp = g_core_codegen_interface->grpc_raw_byte_buffer_create(&slice, 1);
     g_core_codegen_interface->grpc_slice_unref(slice);
+
     return g_core_codegen_interface->ok();
-  } else {
-    BufferWriter writer(bp, kGrpcBufferWriterMaxBufferLength);
-    return msg.SerializeToZeroCopyStream(&writer)
-               ? g_core_codegen_interface->ok()
-               : Status(StatusCode::INTERNAL, "Failed to serialize message");
   }
+  BufferWriter writer(bp, kGrpcBufferWriterMaxBufferLength, byte_size);
+  return msg.SerializeToZeroCopyStream(&writer)
+             ? g_core_codegen_interface->ok()
+             : Status(StatusCode::INTERNAL, "Failed to serialize message");
 }
 
 // BufferReader must be a subclass of io::ZeroCopyInputStream.

include/grpc++/server_builder.h

@@ -202,10 +202,7 @@ class ServerBuilder {
 
   struct SyncServerSettings {
     SyncServerSettings()
-        : num_cqs(GPR_MAX(1, gpr_cpu_num_cores())),
-          min_pollers(1),
-          max_pollers(2),
-          cq_timeout_msec(10000) {}
+        : num_cqs(1), min_pollers(1), max_pollers(2), cq_timeout_msec(10000) {}
 
     /// Number of server completion queues to create to listen to incoming RPCs.
     int num_cqs;

src/core/ext/census/grpc_context.cc

@@ -24,8 +24,8 @@
 void grpc_census_call_set_context(grpc_call* call, census_context* context) {
   GRPC_API_TRACE("grpc_census_call_set_context(call=%p, census_context=%p)", 2,
                  (call, context));
-  if (context != NULL) {
-    grpc_call_context_set(call, GRPC_CONTEXT_TRACING, context, NULL);
+  if (context != nullptr) {
+    grpc_call_context_set(call, GRPC_CONTEXT_TRACING, context, nullptr);
   }
 }
 

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

@@ -46,7 +46,7 @@ typedef struct backup_poller {
 
 static gpr_once g_once = GPR_ONCE_INIT;
 static gpr_mu g_poller_mu;
-static backup_poller* g_poller = NULL;  // guarded by g_poller_mu
+static backup_poller* g_poller = nullptr;  // guarded by g_poller_mu
 // g_poll_interval_ms is set only once at the first time
 // grpc_client_channel_start_backup_polling() is called, after that it is
 // treated as const.
@@ -55,7 +55,7 @@ static int g_poll_interval_ms = DEFAULT_POLL_INTERVAL_MS;
 static void init_globals() {
   gpr_mu_init(&g_poller_mu);
   char* env = gpr_getenv("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS");
-  if (env != NULL) {
+  if (env != nullptr) {
     int poll_interval_ms = gpr_parse_nonnegative_int(env);
     if (poll_interval_ms == -1) {
       gpr_log(GPR_ERROR,
@@ -86,7 +86,7 @@ static void g_poller_unref(grpc_exec_ctx* exec_ctx) {
   if (gpr_unref(&g_poller->refs)) {
     gpr_mu_lock(&g_poller_mu);
     backup_poller* p = g_poller;
-    g_poller = NULL;
+    g_poller = nullptr;
     gpr_mu_unlock(&g_poller_mu);
     gpr_mu_lock(p->pollset_mu);
     p->shutting_down = true;
@@ -113,7 +113,7 @@ static void run_poller(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
     backup_poller_shutdown_unref(exec_ctx, p);
     return;
   }
-  grpc_error* err = grpc_pollset_work(exec_ctx, p->pollset, NULL,
+  grpc_error* err = grpc_pollset_work(exec_ctx, p->pollset, nullptr,
                                       grpc_exec_ctx_now(exec_ctx));
   gpr_mu_unlock(p->pollset_mu);
   GRPC_LOG_IF_ERROR("Run client channel backup poller", err);
@@ -129,7 +129,7 @@ void grpc_client_channel_start_backup_polling(
     return;
   }
   gpr_mu_lock(&g_poller_mu);
-  if (g_poller == NULL) {
+  if (g_poller == nullptr) {
     g_poller = (backup_poller*)gpr_zalloc(sizeof(backup_poller));
     g_poller->pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
     g_poller->shutting_down = false;
@@ -143,9 +143,16 @@ void grpc_client_channel_start_backup_polling(
                     grpc_exec_ctx_now(exec_ctx) + g_poll_interval_ms,
                     &g_poller->run_poller_closure);
   }
+
   gpr_ref(&g_poller->refs);
+  /* Get a reference to g_poller->pollset before releasing g_poller_mu to make
+   * TSAN happy. Otherwise, reading from g_poller (i.e g_poller->pollset) after
+   * releasing the lock and setting g_poller to NULL in g_poller_unref() is
+   * being flagged as a data-race by TSAN */
+  grpc_pollset* pollset = g_poller->pollset;
   gpr_mu_unlock(&g_poller_mu);
-  grpc_pollset_set_add_pollset(exec_ctx, interested_parties, g_poller->pollset);
+
+  grpc_pollset_set_add_pollset(exec_ctx, interested_parties, pollset);
 }
 
 void grpc_client_channel_stop_backup_polling(

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

@@ -115,8 +115,8 @@ static void partly_done(grpc_exec_ctx* exec_ctx, state_watcher* w,
         grpc_channel_get_channel_stack(w->channel));
     grpc_client_channel_watch_connectivity_state(
         exec_ctx, client_channel_elem,
-        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), NULL,
-        &w->on_complete, NULL);
+        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)),
+        nullptr, &w->on_complete, nullptr);
   }
 
   gpr_mu_lock(&w->mu);
@@ -229,7 +229,7 @@ void grpc_channel_watch_connectivity_state(
   w->cq = cq;
   w->tag = tag;
   w->channel = channel;
-  w->error = NULL;
+  w->error = nullptr;
 
   watcher_timer_init_arg* wa =
       (watcher_timer_init_arg*)gpr_malloc(sizeof(watcher_timer_init_arg));

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

@@ -115,7 +115,7 @@ static bool parse_timeout(grpc_json* field, grpc_millis* timeout) {
   buf[len - 1] = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf, '.');
   int nanos = 0;
-  if (decimal_point != NULL) {
+  if (decimal_point != nullptr) {
     *decimal_point = '\0';
     nanos = gpr_parse_nonnegative_int(decimal_point + 1);
     if (nanos == -1) {
@@ -141,14 +141,14 @@ static bool parse_timeout(grpc_json* field, grpc_millis* timeout) {
 static void* method_parameters_create_from_json(const grpc_json* json) {
   wait_for_ready_value wait_for_ready = WAIT_FOR_READY_UNSET;
   grpc_millis timeout = 0;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) continue;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) continue;
     if (strcmp(field->key, "waitForReady") == 0) {
-      if (wait_for_ready != WAIT_FOR_READY_UNSET) return NULL;  // Duplicate.
-      if (!parse_wait_for_ready(field, &wait_for_ready)) return NULL;
+      if (wait_for_ready != WAIT_FOR_READY_UNSET) return nullptr;  // Duplicate.
+      if (!parse_wait_for_ready(field, &wait_for_ready)) return nullptr;
     } else if (strcmp(field->key, "timeout") == 0) {
-      if (timeout > 0) return NULL;  // Duplicate.
-      if (!parse_timeout(field, &timeout)) return NULL;
+      if (timeout > 0) return nullptr;  // Duplicate.
+      if (!parse_timeout(field, &timeout)) return nullptr;
     }
   }
   method_parameters* value =
@@ -234,7 +234,7 @@ static void set_channel_connectivity_state_locked(grpc_exec_ctx* exec_ctx,
    * - Make it possible for policies to return GRPC_CHANNEL_TRANSIENT_FAILURE.
    * - Hand over pending picks from old policies during the switch that happens
    *   when resolver provides an update. */
-  if (chand->lb_policy != NULL) {
+  if (chand->lb_policy != nullptr) {
     if (state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
       /* cancel picks with wait_for_ready=false */
       grpc_lb_policy_cancel_picks_locked(
@@ -266,11 +266,12 @@ static void on_lb_policy_state_changed_locked(grpc_exec_ctx* exec_ctx,
       gpr_log(GPR_DEBUG, "chand=%p: lb_policy=%p state changed to %s", w->chand,
               w->lb_policy, grpc_connectivity_state_name(w->state));
     }
-    if (publish_state == GRPC_CHANNEL_SHUTDOWN && w->chand->resolver != NULL) {
+    if (publish_state == GRPC_CHANNEL_SHUTDOWN &&
+        w->chand->resolver != nullptr) {
       publish_state = GRPC_CHANNEL_TRANSIENT_FAILURE;
       grpc_resolver_channel_saw_error_locked(exec_ctx, w->chand->resolver);
       GRPC_LB_POLICY_UNREF(exec_ctx, w->chand->lb_policy, "channel");
-      w->chand->lb_policy = NULL;
+      w->chand->lb_policy = nullptr;
     }
     set_channel_connectivity_state_locked(exec_ctx, w->chand, publish_state,
                                           GRPC_ERROR_REF(error), "lb_changed");
@@ -318,13 +319,13 @@ static void parse_retry_throttle_params(const grpc_json* field, void* arg) {
   service_config_parsing_state* parsing_state =
       (service_config_parsing_state*)arg;
   if (strcmp(field->key, "retryThrottling") == 0) {
-    if (parsing_state->retry_throttle_data != NULL) return;  // Duplicate.
+    if (parsing_state->retry_throttle_data != nullptr) return;  // Duplicate.
     if (field->type != GRPC_JSON_OBJECT) return;
     int max_milli_tokens = 0;
     int milli_token_ratio = 0;
-    for (grpc_json* sub_field = field->child; sub_field != NULL;
+    for (grpc_json* sub_field = field->child; sub_field != nullptr;
          sub_field = sub_field->next) {
-      if (sub_field->key == NULL) return;
+      if (sub_field->key == nullptr) return;
       if (strcmp(sub_field->key, "maxTokens") == 0) {
         if (max_milli_tokens != 0) return;  // Duplicate.
         if (sub_field->type != GRPC_JSON_NUMBER) return;
@@ -339,7 +340,7 @@ static void parse_retry_throttle_params(const grpc_json* field, void* arg) {
         uint32_t multiplier = 1;
         uint32_t decimal_value = 0;
         const char* decimal_point = strchr(sub_field->value, '.');
-        if (decimal_point != NULL) {
+        if (decimal_point != nullptr) {
           whole_len = (size_t)(decimal_point - sub_field->value);
           multiplier = 1000;
           size_t decimal_len = strlen(decimal_point + 1);
@@ -378,18 +379,18 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
   }
   // Extract the following fields from the resolver result, if non-NULL.
   bool lb_policy_updated = false;
-  char* lb_policy_name_dup = NULL;
+  char* lb_policy_name_dup = nullptr;
   bool lb_policy_name_changed = false;
-  grpc_lb_policy* new_lb_policy = NULL;
-  char* service_config_json = NULL;
-  grpc_server_retry_throttle_data* retry_throttle_data = NULL;
-  grpc_slice_hash_table* method_params_table = NULL;
-  if (chand->resolver_result != NULL) {
+  grpc_lb_policy* new_lb_policy = nullptr;
+  char* service_config_json = nullptr;
+  grpc_server_retry_throttle_data* retry_throttle_data = nullptr;
+  grpc_slice_hash_table* method_params_table = nullptr;
+  if (chand->resolver_result != nullptr) {
     // Find LB policy name.
-    const char* lb_policy_name = NULL;
+    const char* lb_policy_name = nullptr;
     const grpc_arg* channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_LB_POLICY_NAME);
-    if (channel_arg != NULL) {
+    if (channel_arg != nullptr) {
       GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
       lb_policy_name = channel_arg->value.string;
     }
@@ -397,7 +398,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
     // the grpclb policy, regardless of what the resolver actually specified.
     channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_LB_ADDRESSES);
-    if (channel_arg != NULL && channel_arg->type == GRPC_ARG_POINTER) {
+    if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_POINTER) {
       grpc_lb_addresses* addresses =
           (grpc_lb_addresses*)channel_arg->value.pointer.p;
       bool found_balancer_address = false;
@@ -408,7 +409,8 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
         }
       }
       if (found_balancer_address) {
-        if (lb_policy_name != NULL && strcmp(lb_policy_name, "grpclb") != 0) {
+        if (lb_policy_name != nullptr &&
+            strcmp(lb_policy_name, "grpclb") != 0) {
           gpr_log(GPR_INFO,
                   "resolver requested LB policy %s but provided at least one "
                   "balancer address -- forcing use of grpclb LB policy",
@@ -419,7 +421,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
     }
     // Use pick_first if nothing was specified and we didn't select grpclb
     // above.
-    if (lb_policy_name == NULL) lb_policy_name = "pick_first";
+    if (lb_policy_name == nullptr) lb_policy_name = "pick_first";
     grpc_lb_policy_args lb_policy_args;
     lb_policy_args.args = chand->resolver_result;
     lb_policy_args.client_channel_factory = chand->client_channel_factory;
@@ -430,9 +432,9 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
     // only thing that modifies its value, and it can only be invoked
     // once at any given time.
     lb_policy_name_changed =
-        chand->info_lb_policy_name == NULL ||
+        chand->info_lb_policy_name == nullptr ||
         strcmp(chand->info_lb_policy_name, lb_policy_name) != 0;
-    if (chand->lb_policy != NULL && !lb_policy_name_changed) {
+    if (chand->lb_policy != nullptr && !lb_policy_name_changed) {
       // Continue using the same LB policy.  Update with new addresses.
       lb_policy_updated = true;
       grpc_lb_policy_update_locked(exec_ctx, chand->lb_policy, &lb_policy_args);
@@ -440,22 +442,22 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
       // Instantiate new LB policy.
       new_lb_policy =
           grpc_lb_policy_create(exec_ctx, lb_policy_name, &lb_policy_args);
-      if (new_lb_policy == NULL) {
+      if (new_lb_policy == nullptr) {
         gpr_log(GPR_ERROR, "could not create LB policy \"%s\"", lb_policy_name);
       }
     }
     // Find service config.
     channel_arg =
         grpc_channel_args_find(chand->resolver_result, GRPC_ARG_SERVICE_CONFIG);
-    if (channel_arg != NULL) {
+    if (channel_arg != nullptr) {
       GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
       service_config_json = gpr_strdup(channel_arg->value.string);
       grpc_service_config* service_config =
           grpc_service_config_create(service_config_json);
-      if (service_config != NULL) {
+      if (service_config != nullptr) {
         channel_arg =
             grpc_channel_args_find(chand->resolver_result, GRPC_ARG_SERVER_URI);
-        GPR_ASSERT(channel_arg != NULL);
+        GPR_ASSERT(channel_arg != nullptr);
         GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
         grpc_uri* uri =
             grpc_uri_parse(exec_ctx, channel_arg->value.string, true);
@@ -479,7 +481,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
     // The copy will be saved in chand->lb_policy_name below.
     lb_policy_name_dup = gpr_strdup(lb_policy_name);
     grpc_channel_args_destroy(exec_ctx, chand->resolver_result);
-    chand->resolver_result = NULL;
+    chand->resolver_result = nullptr;
   }
   if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
     gpr_log(GPR_DEBUG,
@@ -494,22 +496,22 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
   //
   // First, swap out the data used by cc_get_channel_info().
   gpr_mu_lock(&chand->info_mu);
-  if (lb_policy_name_dup != NULL) {
+  if (lb_policy_name_dup != nullptr) {
     gpr_free(chand->info_lb_policy_name);
     chand->info_lb_policy_name = lb_policy_name_dup;
   }
-  if (service_config_json != NULL) {
+  if (service_config_json != nullptr) {
     gpr_free(chand->info_service_config_json);
     chand->info_service_config_json = service_config_json;
   }
   gpr_mu_unlock(&chand->info_mu);
   // Swap out the retry throttle data.
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_unref(chand->retry_throttle_data);
   }
   chand->retry_throttle_data = retry_throttle_data;
   // Swap out the method params table.
-  if (chand->method_params_table != NULL) {
+  if (chand->method_params_table != nullptr) {
     grpc_slice_hash_table_unref(exec_ctx, chand->method_params_table);
   }
   chand->method_params_table = method_params_table;
@@ -519,9 +521,9 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
   // Note that we do NOT do this if either (a) we updated the existing
   // LB policy above or (b) we failed to create the new LB policy (in
   // which case we want to continue using the most recent one we had).
-  if (new_lb_policy != NULL || error != GRPC_ERROR_NONE ||
-      chand->resolver == NULL) {
-    if (chand->lb_policy != NULL) {
+  if (new_lb_policy != nullptr || error != GRPC_ERROR_NONE ||
+      chand->resolver == nullptr) {
+    if (chand->lb_policy != nullptr) {
       if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
         gpr_log(GPR_DEBUG, "chand=%p: unreffing lb_policy=%p", chand,
                 chand->lb_policy);
@@ -535,17 +537,17 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
   }
   // Now that we've swapped out the relevant fields of chand, check for
   // error or shutdown.
-  if (error != GRPC_ERROR_NONE || chand->resolver == NULL) {
+  if (error != GRPC_ERROR_NONE || chand->resolver == nullptr) {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG, "chand=%p: shutting down", chand);
     }
-    if (chand->resolver != NULL) {
+    if (chand->resolver != nullptr) {
       if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
         gpr_log(GPR_DEBUG, "chand=%p: shutting down resolver", chand);
       }
       grpc_resolver_shutdown_locked(exec_ctx, chand->resolver);
       GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");
-      chand->resolver = NULL;
+      chand->resolver = nullptr;
     }
     set_channel_connectivity_state_locked(
         exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,
@@ -562,7 +564,7 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
     grpc_connectivity_state state = GRPC_CHANNEL_TRANSIENT_FAILURE;
     grpc_error* state_error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("No load balancing policy");
-    if (new_lb_policy != NULL) {
+    if (new_lb_policy != nullptr) {
       if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
         gpr_log(GPR_DEBUG, "chand=%p: initializing new LB policy", chand);
       }
@@ -599,46 +601,46 @@ static void start_transport_op_locked(grpc_exec_ctx* exec_ctx, void* arg,
       (grpc_channel_element*)op->handler_private.extra_arg;
   channel_data* chand = (channel_data*)elem->channel_data;
 
-  if (op->on_connectivity_state_change != NULL) {
+  if (op->on_connectivity_state_change != nullptr) {
     grpc_connectivity_state_notify_on_state_change(
         exec_ctx, &chand->state_tracker, op->connectivity_state,
         op->on_connectivity_state_change);
-    op->on_connectivity_state_change = NULL;
-    op->connectivity_state = NULL;
+    op->on_connectivity_state_change = nullptr;
+    op->connectivity_state = nullptr;
   }
 
-  if (op->send_ping != NULL) {
-    if (chand->lb_policy == NULL) {
+  if (op->send_ping != nullptr) {
+    if (chand->lb_policy == nullptr) {
       GRPC_CLOSURE_SCHED(
           exec_ctx, op->send_ping,
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Ping with no load balancing"));
     } else {
       grpc_lb_policy_ping_one_locked(exec_ctx, chand->lb_policy, op->send_ping);
-      op->bind_pollset = NULL;
+      op->bind_pollset = nullptr;
     }
-    op->send_ping = NULL;
+    op->send_ping = nullptr;
   }
 
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    if (chand->resolver != NULL) {
+    if (chand->resolver != nullptr) {
       set_channel_connectivity_state_locked(
           exec_ctx, chand, GRPC_CHANNEL_SHUTDOWN,
           GRPC_ERROR_REF(op->disconnect_with_error), "disconnect");
       grpc_resolver_shutdown_locked(exec_ctx, chand->resolver);
       GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");
-      chand->resolver = NULL;
+      chand->resolver = nullptr;
       if (!chand->started_resolving) {
         grpc_closure_list_fail_all(&chand->waiting_for_resolver_result_closures,
                                    GRPC_ERROR_REF(op->disconnect_with_error));
         GRPC_CLOSURE_LIST_SCHED(exec_ctx,
                                 &chand->waiting_for_resolver_result_closures);
       }
-      if (chand->lb_policy != NULL) {
+      if (chand->lb_policy != nullptr) {
         grpc_pollset_set_del_pollset_set(exec_ctx,
                                          chand->lb_policy->interested_parties,
                                          chand->interested_parties);
         GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");
-        chand->lb_policy = NULL;
+        chand->lb_policy = nullptr;
       }
     }
     GRPC_ERROR_UNREF(op->disconnect_with_error);
@@ -654,7 +656,7 @@ static void cc_start_transport_op(grpc_exec_ctx* exec_ctx,
   channel_data* chand = (channel_data*)elem->channel_data;
 
   GPR_ASSERT(op->set_accept_stream == false);
-  if (op->bind_pollset != NULL) {
+  if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(exec_ctx, chand->interested_parties,
                                  op->bind_pollset);
   }
@@ -673,15 +675,15 @@ static void cc_get_channel_info(grpc_exec_ctx* exec_ctx,
                                 const grpc_channel_info* info) {
   channel_data* chand = (channel_data*)elem->channel_data;
   gpr_mu_lock(&chand->info_mu);
-  if (info->lb_policy_name != NULL) {
-    *info->lb_policy_name = chand->info_lb_policy_name == NULL
-                                ? NULL
+  if (info->lb_policy_name != nullptr) {
+    *info->lb_policy_name = chand->info_lb_policy_name == nullptr
+                                ? nullptr
                                 : gpr_strdup(chand->info_lb_policy_name);
   }
-  if (info->service_config_json != NULL) {
+  if (info->service_config_json != nullptr) {
     *info->service_config_json =
-        chand->info_service_config_json == NULL
-            ? NULL
+        chand->info_service_config_json == nullptr
+            ? nullptr
             : gpr_strdup(chand->info_service_config_json);
   }
   gpr_mu_unlock(&chand->info_mu);
@@ -700,7 +702,7 @@ static grpc_error* cc_init_channel_elem(grpc_exec_ctx* exec_ctx,
   gpr_mu_init(&chand->external_connectivity_watcher_list_mu);
 
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
-  chand->external_connectivity_watcher_list_head = NULL;
+  chand->external_connectivity_watcher_list_head = nullptr;
   gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
 
   chand->owning_stack = args->channel_stack;
@@ -714,7 +716,7 @@ static grpc_error* cc_init_channel_elem(grpc_exec_ctx* exec_ctx,
   // Record client channel factory.
   const grpc_arg* arg = grpc_channel_args_find(args->channel_args,
                                                GRPC_ARG_CLIENT_CHANNEL_FACTORY);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Missing client channel factory in args for client channel filter");
   }
@@ -728,7 +730,7 @@ static grpc_error* cc_init_channel_elem(grpc_exec_ctx* exec_ctx,
       (grpc_client_channel_factory*)arg->value.pointer.p;
   // Get server name to resolve, using proxy mapper if needed.
   arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVER_URI);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Missing server uri in args for client channel filter");
   }
@@ -736,18 +738,18 @@ static grpc_error* cc_init_channel_elem(grpc_exec_ctx* exec_ctx,
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "server uri arg must be a string");
   }
-  char* proxy_name = NULL;
-  grpc_channel_args* new_args = NULL;
+  char* proxy_name = nullptr;
+  grpc_channel_args* new_args = nullptr;
   grpc_proxy_mappers_map_name(exec_ctx, arg->value.string, args->channel_args,
                               &proxy_name, &new_args);
   // Instantiate resolver.
   chand->resolver = grpc_resolver_create(
-      exec_ctx, proxy_name != NULL ? proxy_name : arg->value.string,
-      new_args != NULL ? new_args : args->channel_args,
+      exec_ctx, proxy_name != nullptr ? proxy_name : arg->value.string,
+      new_args != nullptr ? new_args : args->channel_args,
       chand->interested_parties, chand->combiner);
-  if (proxy_name != NULL) gpr_free(proxy_name);
-  if (new_args != NULL) grpc_channel_args_destroy(exec_ctx, new_args);
-  if (chand->resolver == NULL) {
+  if (proxy_name != nullptr) gpr_free(proxy_name);
+  if (new_args != nullptr) grpc_channel_args_destroy(exec_ctx, new_args);
+  if (chand->resolver == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("resolver creation failed");
   }
   chand->deadline_checking_enabled =
@@ -766,17 +768,17 @@ static void shutdown_resolver_locked(grpc_exec_ctx* exec_ctx, void* arg,
 static void cc_destroy_channel_elem(grpc_exec_ctx* exec_ctx,
                                     grpc_channel_element* elem) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  if (chand->resolver != NULL) {
+  if (chand->resolver != nullptr) {
     GRPC_CLOSURE_SCHED(
         exec_ctx,
         GRPC_CLOSURE_CREATE(shutdown_resolver_locked, chand->resolver,
                             grpc_combiner_scheduler(chand->combiner)),
         GRPC_ERROR_NONE);
   }
-  if (chand->client_channel_factory != NULL) {
+  if (chand->client_channel_factory != nullptr) {
     grpc_client_channel_factory_unref(exec_ctx, chand->client_channel_factory);
   }
-  if (chand->lb_policy != NULL) {
+  if (chand->lb_policy != nullptr) {
     grpc_pollset_set_del_pollset_set(exec_ctx,
                                      chand->lb_policy->interested_parties,
                                      chand->interested_parties);
@@ -784,10 +786,10 @@ static void cc_destroy_channel_elem(grpc_exec_ctx* exec_ctx,
   }
   gpr_free(chand->info_lb_policy_name);
   gpr_free(chand->info_service_config_json);
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_unref(chand->retry_throttle_data);
   }
-  if (chand->method_params_table != NULL) {
+  if (chand->method_params_table != nullptr) {
     grpc_slice_hash_table_unref(exec_ctx, chand->method_params_table);
   }
   grpc_client_channel_stop_backup_polling(exec_ctx, chand->interested_parties);
@@ -870,7 +872,7 @@ grpc_subchannel_call* grpc_client_channel_get_subchannel_call(
 static void waiting_for_pick_batches_add(
     call_data* calld, grpc_transport_stream_op_batch* batch) {
   if (batch->send_initial_metadata) {
-    GPR_ASSERT(calld->initial_metadata_batch == NULL);
+    GPR_ASSERT(calld->initial_metadata_batch == nullptr);
     calld->initial_metadata_batch = batch;
   } else {
     GPR_ASSERT(calld->waiting_for_pick_batches_count < MAX_WAITING_BATCHES);
@@ -912,7 +914,7 @@ static void waiting_for_pick_batches_fail(grpc_exec_ctx* exec_ctx,
                              GRPC_ERROR_REF(error),
                              "waiting_for_pick_batches_fail");
   }
-  if (calld->initial_metadata_batch != NULL) {
+  if (calld->initial_metadata_batch != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
         exec_ctx, calld->initial_metadata_batch, GRPC_ERROR_REF(error),
         calld->call_combiner);
@@ -956,7 +958,7 @@ static void waiting_for_pick_batches_resume(grpc_exec_ctx* exec_ctx,
                              GRPC_ERROR_NONE,
                              "waiting_for_pick_batches_resume");
   }
-  GPR_ASSERT(calld->initial_metadata_batch != NULL);
+  GPR_ASSERT(calld->initial_metadata_batch != nullptr);
   grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call,
                                   calld->initial_metadata_batch);
 }
@@ -971,14 +973,14 @@ static void apply_service_config_to_call_locked(grpc_exec_ctx* exec_ctx,
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: applying service config to call",
             chand, calld);
   }
-  if (chand->retry_throttle_data != NULL) {
+  if (chand->retry_throttle_data != nullptr) {
     calld->retry_throttle_data =
         grpc_server_retry_throttle_data_ref(chand->retry_throttle_data);
   }
-  if (chand->method_params_table != NULL) {
+  if (chand->method_params_table != nullptr) {
     calld->method_params = (method_parameters*)grpc_method_config_table_get(
         exec_ctx, chand->method_params_table, calld->path);
-    if (calld->method_params != NULL) {
+    if (calld->method_params != nullptr) {
       method_parameters_ref(calld->method_params);
       // If the deadline from the service config is shorter than the one
       // from the client API, reset the deadline timer.
@@ -1031,7 +1033,7 @@ static void pick_done_locked(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                              grpc_error* error) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
-  if (calld->connected_subchannel == NULL) {
+  if (calld->connected_subchannel == nullptr) {
     // Failed to create subchannel.
     GRPC_ERROR_UNREF(calld->error);
     calld->error = error == GRPC_ERROR_NONE
@@ -1072,7 +1074,7 @@ static void pick_callback_cancel_locked(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_call_element* elem = (grpc_call_element*)arg;
   channel_data* chand = (channel_data*)elem->channel_data;
   call_data* calld = (call_data*)elem->call_data;
-  if (calld->lb_policy != NULL) {
+  if (calld->lb_policy != nullptr) {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: cancelling pick from LB policy %p",
               chand, calld, calld->lb_policy);
@@ -1095,9 +1097,9 @@ static void pick_callback_done_locked(grpc_exec_ctx* exec_ctx, void* arg,
     gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed asynchronously",
             chand, calld);
   }
-  GPR_ASSERT(calld->lb_policy != NULL);
+  GPR_ASSERT(calld->lb_policy != nullptr);
   GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-  calld->lb_policy = NULL;
+  calld->lb_policy = nullptr;
   async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
 }
 
@@ -1123,7 +1125,7 @@ static bool pick_callback_start_locked(grpc_exec_ctx* exec_ctx,
       initial_metadata_flags &
       GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
   const bool wait_for_ready_set_from_service_config =
-      calld->method_params != NULL &&
+      calld->method_params != nullptr &&
       calld->method_params->wait_for_ready != WAIT_FOR_READY_UNSET;
   if (!wait_for_ready_set_from_api && wait_for_ready_set_from_service_config) {
     if (calld->method_params->wait_for_ready == WAIT_FOR_READY_TRUE) {
@@ -1143,7 +1145,7 @@ static bool pick_callback_start_locked(grpc_exec_ctx* exec_ctx,
                     grpc_combiner_scheduler(chand->combiner));
   const bool pick_done = grpc_lb_policy_pick_locked(
       exec_ctx, chand->lb_policy, &inputs, &calld->connected_subchannel,
-      calld->subchannel_call_context, NULL, &calld->lb_pick_closure);
+      calld->subchannel_call_context, nullptr, &calld->lb_pick_closure);
   if (pick_done) {
     /* synchronous grpc_lb_policy_pick call. Unref the LB policy. */
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
@@ -1151,7 +1153,7 @@ static bool pick_callback_start_locked(grpc_exec_ctx* exec_ctx,
               chand, calld);
     }
     GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-    calld->lb_policy = NULL;
+    calld->lb_policy = nullptr;
   } else {
     GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback_cancel");
     grpc_call_combiner_set_notify_on_cancel(
@@ -1231,7 +1233,7 @@ static void pick_after_resolver_result_done_locked(grpc_exec_ctx* exec_ctx,
               chand, calld);
     }
     async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
-  } else if (chand->lb_policy != NULL) {
+  } else if (chand->lb_policy != nullptr) {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver returned, doing pick",
               chand, calld);
@@ -1252,7 +1254,7 @@ static void pick_after_resolver_result_done_locked(grpc_exec_ctx* exec_ctx,
   // removed in https://github.com/grpc/grpc/pull/12297.  Need to figure
   // out what is actually causing this to occur and then figure out the
   // right way to deal with it.
-  else if (chand->resolver != NULL) {
+  else if (chand->resolver != nullptr) {
     // No LB policy, so try again.
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG,
@@ -1299,8 +1301,8 @@ static void start_pick_locked(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_call_element* elem = (grpc_call_element*)arg;
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
-  GPR_ASSERT(calld->connected_subchannel == NULL);
-  if (chand->lb_policy != NULL) {
+  GPR_ASSERT(calld->connected_subchannel == nullptr);
+  if (chand->lb_policy != nullptr) {
     // We already have an LB policy, so ask it for a pick.
     if (pick_callback_start_locked(exec_ctx, elem)) {
       // Pick completed synchronously.
@@ -1309,7 +1311,7 @@ static void start_pick_locked(grpc_exec_ctx* exec_ctx, void* arg,
     }
   } else {
     // We do not yet have an LB policy, so wait for a resolver result.
-    if (chand->resolver == NULL) {
+    if (chand->resolver == nullptr) {
       pick_done_locked(exec_ctx, elem,
                        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
       return;
@@ -1331,7 +1333,7 @@ static void start_pick_locked(grpc_exec_ctx* exec_ctx, void* arg,
 static void on_complete(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)arg;
   call_data* calld = (call_data*)elem->call_data;
-  if (calld->retry_throttle_data != NULL) {
+  if (calld->retry_throttle_data != nullptr) {
     if (error == GRPC_ERROR_NONE) {
       grpc_server_retry_throttle_data_record_success(
           calld->retry_throttle_data);
@@ -1382,7 +1384,7 @@ static void cc_start_transport_stream_op_batch(
     }
     // If we have a subchannel call, send the cancellation batch down.
     // Otherwise, fail all pending batches.
-    if (calld->subchannel_call != NULL) {
+    if (calld->subchannel_call != nullptr) {
       grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call, batch);
     } else {
       waiting_for_pick_batches_add(calld, batch);
@@ -1394,7 +1396,7 @@ static void cc_start_transport_stream_op_batch(
   // Intercept on_complete for recv_trailing_metadata so that we can
   // check retry throttle status.
   if (batch->recv_trailing_metadata) {
-    GPR_ASSERT(batch->on_complete != NULL);
+    GPR_ASSERT(batch->on_complete != nullptr);
     calld->original_on_complete = batch->on_complete;
     GRPC_CLOSURE_INIT(&calld->on_complete, on_complete, elem,
                       grpc_schedule_on_exec_ctx);
@@ -1404,7 +1406,7 @@ static void cc_start_transport_stream_op_batch(
   // Note that once we have completed the pick, we do not need to enter
   // the channel combiner, which is more efficient (especially for
   // streaming calls).
-  if (calld->subchannel_call != NULL) {
+  if (calld->subchannel_call != nullptr) {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG,
               "chand=%p calld=%p: sending batch to subchannel_call=%p", chand,
@@ -1473,25 +1475,25 @@ static void cc_destroy_call_elem(grpc_exec_ctx* exec_ctx,
     grpc_deadline_state_destroy(exec_ctx, elem);
   }
   grpc_slice_unref_internal(exec_ctx, calld->path);
-  if (calld->method_params != NULL) {
+  if (calld->method_params != nullptr) {
     method_parameters_unref(calld->method_params);
   }
   GRPC_ERROR_UNREF(calld->error);
-  if (calld->subchannel_call != NULL) {
+  if (calld->subchannel_call != nullptr) {
     grpc_subchannel_call_set_cleanup_closure(calld->subchannel_call,
                                              then_schedule_closure);
-    then_schedule_closure = NULL;
+    then_schedule_closure = nullptr;
     GRPC_SUBCHANNEL_CALL_UNREF(exec_ctx, calld->subchannel_call,
                                "client_channel_destroy_call");
   }
-  GPR_ASSERT(calld->lb_policy == NULL);
+  GPR_ASSERT(calld->lb_policy == nullptr);
   GPR_ASSERT(calld->waiting_for_pick_batches_count == 0);
-  if (calld->connected_subchannel != NULL) {
+  if (calld->connected_subchannel != nullptr) {
     GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, calld->connected_subchannel,
                                     "picked");
   }
   for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
-    if (calld->subchannel_call_context[i].value != NULL) {
+    if (calld->subchannel_call_context[i].value != nullptr) {
       calld->subchannel_call_context[i].destroy(
           calld->subchannel_call_context[i].value);
     }
@@ -1527,11 +1529,11 @@ const grpc_channel_filter grpc_client_channel_filter = {
 static void try_to_connect_locked(grpc_exec_ctx* exec_ctx, void* arg,
                                   grpc_error* error_ignored) {
   channel_data* chand = (channel_data*)arg;
-  if (chand->lb_policy != NULL) {
+  if (chand->lb_policy != nullptr) {
     grpc_lb_policy_exit_idle_locked(exec_ctx, chand->lb_policy);
   } else {
     chand->exit_idle_when_lb_policy_arrives = true;
-    if (!chand->started_resolving && chand->resolver != NULL) {
+    if (!chand->started_resolving && chand->resolver != nullptr) {
       start_resolving_locked(exec_ctx, chand);
     }
   }
@@ -1569,7 +1571,7 @@ static external_connectivity_watcher* lookup_external_connectivity_watcher(
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
   external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL && w->on_complete != on_complete) {
+  while (w != nullptr && w->on_complete != on_complete) {
     w = w->next;
   }
   gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
@@ -1599,7 +1601,7 @@ static void external_connectivity_watcher_list_remove(
   }
   external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL) {
+  while (w != nullptr) {
     if (w->next == too_remove) {
       w->next = w->next->next;
       gpr_mu_unlock(&chand->external_connectivity_watcher_list_mu);
@@ -1618,7 +1620,7 @@ int grpc_client_channel_num_external_connectivity_watchers(
   gpr_mu_lock(&chand->external_connectivity_watcher_list_mu);
   external_connectivity_watcher* w =
       chand->external_connectivity_watcher_list_head;
-  while (w != NULL) {
+  while (w != nullptr) {
     count++;
     w = w->next;
   }
@@ -1643,8 +1645,8 @@ static void on_external_watch_complete_locked(grpc_exec_ctx* exec_ctx,
 static void watch_connectivity_state_locked(grpc_exec_ctx* exec_ctx, void* arg,
                                             grpc_error* error_ignored) {
   external_connectivity_watcher* w = (external_connectivity_watcher*)arg;
-  external_connectivity_watcher* found = NULL;
-  if (w->state != NULL) {
+  external_connectivity_watcher* found = nullptr;
+  if (w->state != nullptr) {
     external_connectivity_watcher_list_append(w->chand, w);
     GRPC_CLOSURE_RUN(exec_ctx, w->watcher_timer_init, GRPC_ERROR_NONE);
     GRPC_CLOSURE_INIT(&w->my_closure, on_external_watch_complete_locked, w,
@@ -1652,12 +1654,12 @@ static void watch_connectivity_state_locked(grpc_exec_ctx* exec_ctx, void* arg,
     grpc_connectivity_state_notify_on_state_change(
         exec_ctx, &w->chand->state_tracker, w->state, &w->my_closure);
   } else {
-    GPR_ASSERT(w->watcher_timer_init == NULL);
+    GPR_ASSERT(w->watcher_timer_init == nullptr);
     found = lookup_external_connectivity_watcher(w->chand, w->on_complete);
     if (found) {
       GPR_ASSERT(found->on_complete == w->on_complete);
       grpc_connectivity_state_notify_on_state_change(
-          exec_ctx, &found->chand->state_tracker, NULL, &found->my_closure);
+          exec_ctx, &found->chand->state_tracker, nullptr, &found->my_closure);
     }
     grpc_polling_entity_del_from_pollset_set(exec_ctx, &w->pollent,
                                              w->chand->interested_parties);

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

@@ -37,7 +37,7 @@
 static bool append_filter(grpc_exec_ctx* exec_ctx,
                           grpc_channel_stack_builder* builder, void* arg) {
   return grpc_channel_stack_builder_append_filter(
-      builder, (const grpc_channel_filter*)arg, NULL, NULL);
+      builder, (const grpc_channel_filter*)arg, nullptr, nullptr);
 }
 
 static bool set_default_host_if_unset(grpc_exec_ctx* exec_ctx,
@@ -53,7 +53,7 @@ static bool set_default_host_if_unset(grpc_exec_ctx* exec_ctx,
   }
   char* default_authority = grpc_get_default_authority(
       exec_ctx, grpc_channel_stack_builder_get_target(builder));
-  if (default_authority != NULL) {
+  if (default_authority != nullptr) {
     grpc_arg arg = grpc_channel_arg_string_create(
         (char*)GRPC_ARG_DEFAULT_AUTHORITY, default_authority);
     grpc_channel_args* new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
@@ -73,7 +73,7 @@ extern "C" void grpc_client_channel_init(void) {
   grpc_register_http_proxy_mapper();
   grpc_subchannel_index_init();
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MIN,
-                                   set_default_host_if_unset, NULL);
+                                   set_default_host_if_unset, nullptr);
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
       (void*)&grpc_client_channel_filter);

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

@@ -65,10 +65,10 @@ static void http_connect_handshaker_unref(grpc_exec_ctx* exec_ctx,
                                           http_connect_handshaker* handshaker) {
   if (gpr_unref(&handshaker->refcount)) {
     gpr_mu_destroy(&handshaker->mu);
-    if (handshaker->endpoint_to_destroy != NULL) {
+    if (handshaker->endpoint_to_destroy != nullptr) {
       grpc_endpoint_destroy(exec_ctx, handshaker->endpoint_to_destroy);
     }
-    if (handshaker->read_buffer_to_destroy != NULL) {
+    if (handshaker->read_buffer_to_destroy != nullptr) {
       grpc_slice_buffer_destroy_internal(exec_ctx,
                                          handshaker->read_buffer_to_destroy);
       gpr_free(handshaker->read_buffer_to_destroy);
@@ -85,11 +85,11 @@ static void http_connect_handshaker_unref(grpc_exec_ctx* exec_ctx,
 static void cleanup_args_for_failure_locked(
     grpc_exec_ctx* exec_ctx, http_connect_handshaker* handshaker) {
   handshaker->endpoint_to_destroy = handshaker->args->endpoint;
-  handshaker->args->endpoint = NULL;
+  handshaker->args->endpoint = nullptr;
   handshaker->read_buffer_to_destroy = handshaker->args->read_buffer;
-  handshaker->args->read_buffer = NULL;
+  handshaker->args->read_buffer = nullptr;
   grpc_channel_args_destroy(exec_ctx, handshaker->args->args);
-  handshaker->args->args = NULL;
+  handshaker->args->args = nullptr;
 }
 
 // If the handshake failed or we're shutting down, clean up and invoke the
@@ -260,7 +260,7 @@ static void http_connect_handshaker_do_handshake(
   // If not found, invoke on_handshake_done without doing anything.
   const grpc_arg* arg =
       grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
     gpr_mu_lock(&handshaker->mu);
@@ -273,11 +273,11 @@ static void http_connect_handshaker_do_handshake(
   char* server_name = arg->value.string;
   // Get headers from channel args.
   arg = grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
-  grpc_http_header* headers = NULL;
+  grpc_http_header* headers = nullptr;
   size_t num_headers = 0;
-  char** header_strings = NULL;
+  char** header_strings = nullptr;
   size_t num_header_strings = 0;
-  if (arg != NULL) {
+  if (arg != nullptr) {
     GPR_ASSERT(arg->type == GRPC_ARG_STRING);
     gpr_string_split(arg->value.string, "\n", &header_strings,
                      &num_header_strings);
@@ -285,7 +285,7 @@ static void http_connect_handshaker_do_handshake(
                                             num_header_strings);
     for (size_t i = 0; i < num_header_strings; ++i) {
       char* sep = strchr(header_strings[i], ':');
-      if (sep == NULL) {
+      if (sep == nullptr) {
         gpr_log(GPR_ERROR, "skipping unparseable HTTP CONNECT header: %s",
                 header_strings[i]);
         continue;

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

@@ -41,15 +41,15 @@
  * responsibility to gpr_free user_cred.
  */
 static char* get_http_proxy_server(grpc_exec_ctx* exec_ctx, char** user_cred) {
-  GPR_ASSERT(user_cred != NULL);
-  char* proxy_name = NULL;
+  GPR_ASSERT(user_cred != nullptr);
+  char* proxy_name = nullptr;
   char* uri_str = gpr_getenv("http_proxy");
-  char** authority_strs = NULL;
+  char** authority_strs = nullptr;
   size_t authority_nstrs;
-  if (uri_str == NULL) return NULL;
+  if (uri_str == nullptr) return nullptr;
   grpc_uri* uri =
       grpc_uri_parse(exec_ctx, uri_str, false /* suppress_errors */);
-  if (uri == NULL || uri->authority == NULL) {
+  if (uri == nullptr || uri->authority == nullptr) {
     gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var");
     goto done;
   }
@@ -73,7 +73,7 @@ static char* get_http_proxy_server(grpc_exec_ctx* exec_ctx, char** user_cred) {
     for (size_t i = 0; i < authority_nstrs; i++) {
       gpr_free(authority_strs[i]);
     }
-    proxy_name = NULL;
+    proxy_name = nullptr;
   }
   gpr_free(authority_strs);
 done:
@@ -88,13 +88,13 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
                                   const grpc_channel_args* args,
                                   char** name_to_resolve,
                                   grpc_channel_args** new_args) {
-  char* user_cred = NULL;
+  char* user_cred = nullptr;
   *name_to_resolve = get_http_proxy_server(exec_ctx, &user_cred);
-  if (*name_to_resolve == NULL) return false;
-  char* no_proxy_str = NULL;
+  if (*name_to_resolve == nullptr) return false;
+  char* no_proxy_str = nullptr;
   grpc_uri* uri =
       grpc_uri_parse(exec_ctx, server_uri, false /* suppress_errors */);
-  if (uri == NULL || uri->path[0] == '\0') {
+  if (uri == nullptr || uri->path[0] == '\0') {
     gpr_log(GPR_ERROR,
             "'http_proxy' environment variable set, but cannot "
             "parse server URI '%s' -- not using proxy",
@@ -107,7 +107,7 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
     goto no_use_proxy;
   }
   no_proxy_str = gpr_getenv("no_proxy");
-  if (no_proxy_str != NULL) {
+  if (no_proxy_str != nullptr) {
     static const char* NO_PROXY_SEPARATOR = ",";
     bool use_proxy = true;
     char* server_host;
@@ -149,7 +149,7 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
   args_to_add[0] = grpc_channel_arg_string_create(
       (char*)GRPC_ARG_HTTP_CONNECT_SERVER,
       uri->path[0] == '/' ? uri->path + 1 : uri->path);
-  if (user_cred != NULL) {
+  if (user_cred != nullptr) {
     /* Use base64 encoding for user credentials as stated in RFC 7617 */
     char* encoded_user_cred =
         grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
@@ -167,9 +167,9 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
   gpr_free(user_cred);
   return true;
 no_use_proxy:
-  if (uri != NULL) grpc_uri_destroy(uri);
+  if (uri != nullptr) grpc_uri_destroy(uri);
   gpr_free(*name_to_resolve);
-  *name_to_resolve = NULL;
+  *name_to_resolve = nullptr;
   gpr_free(user_cred);
   return false;
 }

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

@@ -72,8 +72,8 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
                                   const grpc_call_element_args* args) {
   call_data* calld = (call_data*)elem->call_data;
   // Get stats object from context and take a ref.
-  GPR_ASSERT(args->context != NULL);
-  GPR_ASSERT(args->context[GRPC_GRPCLB_CLIENT_STATS].value != NULL);
+  GPR_ASSERT(args->context != nullptr);
+  GPR_ASSERT(args->context[GRPC_GRPCLB_CLIENT_STATS].value != nullptr);
   calld->client_stats = grpc_grpclb_client_stats_ref(
       (grpc_grpclb_client_stats*)args->context[GRPC_GRPCLB_CLIENT_STATS].value);
   // Record call started.

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

@@ -35,7 +35,7 @@ grpc_channel* grpc_lb_policy_grpclb_create_lb_channel(
   grpc_channel_args* new_args = args;
   grpc_channel_credentials* channel_credentials =
       grpc_channel_credentials_find_in_args(args);
-  if (channel_credentials != NULL) {
+  if (channel_credentials != nullptr) {
     /* Substitute the channel credentials with a version without call
      * credentials: the load balancer is not necessarily trusted to handle
      * bearer token credentials */
@@ -43,7 +43,7 @@ grpc_channel* grpc_lb_policy_grpclb_create_lb_channel(
     grpc_channel_credentials* creds_sans_call_creds =
         grpc_channel_credentials_duplicate_without_call_credentials(
             channel_credentials);
-    GPR_ASSERT(creds_sans_call_creds != NULL);
+    GPR_ASSERT(creds_sans_call_creds != nullptr);
     grpc_arg args_to_add[] = {
         grpc_channel_credentials_to_arg(creds_sans_call_creds)};
     /* Create the new set of channel args */
@@ -55,7 +55,7 @@ grpc_channel* grpc_lb_policy_grpclb_create_lb_channel(
   grpc_channel* lb_channel = grpc_client_channel_factory_create_channel(
       exec_ctx, client_channel_factory, lb_service_target_addresses,
       GRPC_CLIENT_CHANNEL_TYPE_LOAD_BALANCING, new_args);
-  if (channel_credentials != NULL) {
+  if (channel_credentials != nullptr) {
     grpc_channel_args_destroy(exec_ctx, new_args);
   }
   return lb_channel;

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

@@ -87,7 +87,7 @@ void grpc_grpclb_client_stats_add_call_dropped_locked(
   gpr_atm_full_fetch_add(&client_stats->num_calls_started, (gpr_atm)1);
   gpr_atm_full_fetch_add(&client_stats->num_calls_finished, (gpr_atm)1);
   // Record the drop.
-  if (client_stats->drop_token_counts == NULL) {
+  if (client_stats->drop_token_counts == nullptr) {
     client_stats->drop_token_counts =
         (grpc_grpclb_dropped_call_counts*)gpr_zalloc(
             sizeof(grpc_grpclb_dropped_call_counts));
@@ -136,12 +136,12 @@ void grpc_grpclb_client_stats_get_locked(
       num_calls_finished_known_received,
       &client_stats->num_calls_finished_known_received);
   *drop_token_counts = client_stats->drop_token_counts;
-  client_stats->drop_token_counts = NULL;
+  client_stats->drop_token_counts = nullptr;
 }
 
 void grpc_grpclb_dropped_call_counts_destroy(
     grpc_grpclb_dropped_call_counts* drop_entries) {
-  if (drop_entries != NULL) {
+  if (drop_entries != nullptr) {
     for (size_t i = 0; i < drop_entries->num_entries; ++i) {
       gpr_free(drop_entries->token_counts[i].token);
     }

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

@@ -89,7 +89,7 @@ static bool encode_drops(pb_ostream_t* stream, const pb_field_t* field,
                          void* const* arg) {
   grpc_grpclb_dropped_call_counts* drop_entries =
       (grpc_grpclb_dropped_call_counts*)*arg;
-  if (drop_entries == NULL) return true;
+  if (drop_entries == nullptr) return true;
   for (size_t i = 0; i < drop_entries->num_entries; ++i) {
     if (!pb_encode_tag_for_field(stream, field)) return false;
     grpc_lb_v1_ClientStatsPerToken drop_message;
@@ -165,10 +165,10 @@ grpc_grpclb_initial_response* grpc_grpclb_initial_response_parse(
   memset(&res, 0, sizeof(grpc_grpclb_response));
   if (!pb_decode(&stream, grpc_lb_v1_LoadBalanceResponse_fields, &res)) {
     gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&stream));
-    return NULL;
+    return nullptr;
   }
 
-  if (!res.has_initial_response) return NULL;
+  if (!res.has_initial_response) return nullptr;
 
   grpc_grpclb_initial_response* initial_res =
       (grpc_grpclb_initial_response*)gpr_malloc(
@@ -196,7 +196,7 @@ grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
   if (!status) {
     gpr_free(sl);
     gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&stream));
-    return NULL;
+    return nullptr;
   }
   // Second pass: populate servers.
   if (sl->num_servers > 0) {
@@ -212,7 +212,7 @@ grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
     if (!status) {
       grpc_grpclb_destroy_serverlist(sl);
       gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&stream));
-      return NULL;
+      return nullptr;
     }
   }
   if (res.server_list.has_expiration_interval) {
@@ -222,7 +222,7 @@ grpc_grpclb_serverlist* grpc_grpclb_response_parse_serverlist(
 }
 
 void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist* serverlist) {
-  if (serverlist == NULL) {
+  if (serverlist == nullptr) {
     return;
   }
   for (size_t i = 0; i < serverlist->num_servers; i++) {
@@ -251,7 +251,7 @@ grpc_grpclb_serverlist* grpc_grpclb_serverlist_copy(
 
 bool grpc_grpclb_serverlist_equals(const grpc_grpclb_serverlist* lhs,
                                    const grpc_grpclb_serverlist* rhs) {
-  if (lhs == NULL || rhs == NULL) {
+  if (lhs == nullptr || rhs == nullptr) {
     return false;
   }
   if (lhs->num_servers != rhs->num_servers) {

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

@@ -60,9 +60,9 @@ typedef struct {
 
 static void pf_destroy(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) {
   pick_first_lb_policy* p = (pick_first_lb_policy*)pol;
-  GPR_ASSERT(p->subchannel_list == NULL);
-  GPR_ASSERT(p->latest_pending_subchannel_list == NULL);
-  GPR_ASSERT(p->pending_picks == NULL);
+  GPR_ASSERT(p->subchannel_list == nullptr);
+  GPR_ASSERT(p->latest_pending_subchannel_list == nullptr);
+  GPR_ASSERT(p->pending_picks == nullptr);
   grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker);
   gpr_free(p);
   grpc_subchannel_index_unref();
@@ -78,24 +78,24 @@ static void shutdown_locked(grpc_exec_ctx* exec_ctx, pick_first_lb_policy* p,
   }
   p->shutdown = true;
   pending_pick* pp;
-  while ((pp = p->pending_picks) != NULL) {
+  while ((pp = p->pending_picks) != nullptr) {
     p->pending_picks = pp->next;
-    *pp->target = NULL;
+    *pp->target = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete, GRPC_ERROR_REF(error));
     gpr_free(pp);
   }
   grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
                               GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(error),
                               "shutdown");
-  if (p->subchannel_list != NULL) {
+  if (p->subchannel_list != nullptr) {
     grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
                                                "pf_shutdown");
-    p->subchannel_list = NULL;
+    p->subchannel_list = nullptr;
   }
-  if (p->latest_pending_subchannel_list != NULL) {
+  if (p->latest_pending_subchannel_list != nullptr) {
     grpc_lb_subchannel_list_shutdown_and_unref(
         exec_ctx, p->latest_pending_subchannel_list, "pf_shutdown");
-    p->latest_pending_subchannel_list = NULL;
+    p->latest_pending_subchannel_list = nullptr;
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -110,11 +110,11 @@ static void pf_cancel_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
                                   grpc_error* error) {
   pick_first_lb_policy* p = (pick_first_lb_policy*)pol;
   pending_pick* pp = p->pending_picks;
-  p->pending_picks = NULL;
-  while (pp != NULL) {
+  p->pending_picks = nullptr;
+  while (pp != nullptr) {
     pending_pick* next = pp->next;
     if (pp->target == target) {
-      *target = NULL;
+      *target = nullptr;
       GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete,
                          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Pick Cancelled", &error, 1));
@@ -134,8 +134,8 @@ static void pf_cancel_picks_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
                                    grpc_error* error) {
   pick_first_lb_policy* p = (pick_first_lb_policy*)pol;
   pending_pick* pp = p->pending_picks;
-  p->pending_picks = NULL;
-  while (pp != NULL) {
+  p->pending_picks = nullptr;
+  while (pp != nullptr) {
     pending_pick* next = pp->next;
     if ((pp->initial_metadata_flags & initial_metadata_flags_mask) ==
         initial_metadata_flags_eq) {
@@ -155,7 +155,8 @@ static void pf_cancel_picks_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
 static void start_picking_locked(grpc_exec_ctx* exec_ctx,
                                  pick_first_lb_policy* p) {
   p->started_picking = true;
-  if (p->subchannel_list != NULL && p->subchannel_list->num_subchannels > 0) {
+  if (p->subchannel_list != nullptr &&
+      p->subchannel_list->num_subchannels > 0) {
     p->subchannel_list->checking_subchannel = 0;
     grpc_lb_subchannel_list_ref_for_connectivity_watch(
         p->subchannel_list, "connectivity_watch+start_picking");
@@ -178,7 +179,7 @@ static int pf_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
                           grpc_closure* on_complete) {
   pick_first_lb_policy* p = (pick_first_lb_policy*)pol;
   // If we have a selected subchannel already, return synchronously.
-  if (p->selected != NULL) {
+  if (p->selected != nullptr) {
     *target = GRPC_CONNECTED_SUBCHANNEL_REF(p->selected->connected_subchannel,
                                             "picked");
     return 1;
@@ -242,8 +243,8 @@ static void pf_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
   pick_first_lb_policy* p = (pick_first_lb_policy*)policy;
   const grpc_arg* arg =
       grpc_channel_args_find(args->args, GRPC_ARG_LB_ADDRESSES);
-  if (arg == NULL || arg->type != GRPC_ARG_POINTER) {
-    if (p->subchannel_list == NULL) {
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) {
+    if (p->subchannel_list == nullptr) {
       // If we don't have a current subchannel list, go into TRANSIENT FAILURE.
       grpc_connectivity_state_set(
           exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
@@ -274,18 +275,18 @@ static void pf_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
         exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update"),
         "pf_update_empty");
-    if (p->subchannel_list != NULL) {
+    if (p->subchannel_list != nullptr) {
       grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
                                                  "sl_shutdown_empty_update");
     }
     p->subchannel_list = subchannel_list;  // Empty list.
-    p->selected = NULL;
+    p->selected = nullptr;
     return;
   }
-  if (p->selected == NULL) {
+  if (p->selected == nullptr) {
     // We don't yet have a selected subchannel, so replace the current
     // subchannel list immediately.
-    if (p->subchannel_list != NULL) {
+    if (p->subchannel_list != nullptr) {
       grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
                                                  "pf_update_before_selected");
     }
@@ -307,12 +308,12 @@ static void pf_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
         grpc_lb_subchannel_list_ref_for_connectivity_watch(
             subchannel_list, "connectivity_watch+replace_selected");
         grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
-        if (p->subchannel_list != NULL) {
+        if (p->subchannel_list != nullptr) {
           grpc_lb_subchannel_list_shutdown_and_unref(
               exec_ctx, p->subchannel_list, "pf_update_includes_selected");
         }
         p->subchannel_list = subchannel_list;
-        if (p->selected->connected_subchannel != NULL) {
+        if (p->selected->connected_subchannel != nullptr) {
           sd->connected_subchannel = GRPC_CONNECTED_SUBCHANNEL_REF(
               p->selected->connected_subchannel, "pf_update_includes_selected");
         }
@@ -321,11 +322,11 @@ static void pf_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
         // If there was a previously pending update (which may or may
         // not have contained the currently selected subchannel), drop
         // it, so that it doesn't override what we've done here.
-        if (p->latest_pending_subchannel_list != NULL) {
+        if (p->latest_pending_subchannel_list != nullptr) {
           grpc_lb_subchannel_list_shutdown_and_unref(
               exec_ctx, p->latest_pending_subchannel_list,
               "pf_update_includes_selected+outdated");
-          p->latest_pending_subchannel_list = NULL;
+          p->latest_pending_subchannel_list = nullptr;
         }
         return;
       }
@@ -334,7 +335,7 @@ static void pf_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
     // pending subchannel list to the new subchannel list.  We will wait
     // for it to report READY before swapping it into the current
     // subchannel list.
-    if (p->latest_pending_subchannel_list != NULL) {
+    if (p->latest_pending_subchannel_list != nullptr) {
       if (GRPC_TRACER_ON(grpc_lb_pick_first_trace)) {
         gpr_log(GPR_DEBUG,
                 "Pick First %p Shutting down latest pending subchannel list "
@@ -402,12 +403,12 @@ static void pf_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
     // If the new state is anything other than READY and there is a
     // pending update, switch to the pending update.
     if (sd->curr_connectivity_state != GRPC_CHANNEL_READY &&
-        p->latest_pending_subchannel_list != NULL) {
-      p->selected = NULL;
+        p->latest_pending_subchannel_list != nullptr) {
+      p->selected = nullptr;
       grpc_lb_subchannel_list_shutdown_and_unref(
           exec_ctx, p->subchannel_list, "selected_not_ready+switch_to_update");
       p->subchannel_list = p->latest_pending_subchannel_list;
-      p->latest_pending_subchannel_list = NULL;
+      p->latest_pending_subchannel_list = nullptr;
       grpc_connectivity_state_set(
           exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
           GRPC_ERROR_REF(error), "selected_not_ready+switch_to_update");
@@ -440,128 +441,111 @@ static void pf_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
   //    for a subchannel in p->latest_pending_subchannel_list.  The
   //    goal here is to find a subchannel from the update that we can
   //    select in place of the current one.
-  if (sd->curr_connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
-      sd->curr_connectivity_state == GRPC_CHANNEL_SHUTDOWN) {
-    grpc_lb_subchannel_data_stop_connectivity_watch(exec_ctx, sd);
-  }
-  while (true) {
-    switch (sd->curr_connectivity_state) {
-      case GRPC_CHANNEL_READY: {
-        // Case 2.  Promote p->latest_pending_subchannel_list to
-        // p->subchannel_list.
-        if (sd->subchannel_list == p->latest_pending_subchannel_list) {
-          GPR_ASSERT(p->subchannel_list != NULL);
-          grpc_lb_subchannel_list_shutdown_and_unref(
-              exec_ctx, p->subchannel_list, "finish_update");
-          p->subchannel_list = p->latest_pending_subchannel_list;
-          p->latest_pending_subchannel_list = NULL;
-        }
-        // Cases 1 and 2.
-        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
-                                    GRPC_CHANNEL_READY, GRPC_ERROR_NONE,
-                                    "connecting_ready");
-        sd->connected_subchannel = GRPC_CONNECTED_SUBCHANNEL_REF(
-            grpc_subchannel_get_connected_subchannel(sd->subchannel),
-            "connected");
-        p->selected = sd;
+  switch (sd->curr_connectivity_state) {
+    case GRPC_CHANNEL_READY: {
+      // Case 2.  Promote p->latest_pending_subchannel_list to
+      // p->subchannel_list.
+      if (sd->subchannel_list == p->latest_pending_subchannel_list) {
+        GPR_ASSERT(p->subchannel_list != nullptr);
+        grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
+                                                   "finish_update");
+        p->subchannel_list = p->latest_pending_subchannel_list;
+        p->latest_pending_subchannel_list = nullptr;
+      }
+      // Cases 1 and 2.
+      grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                  GRPC_CHANNEL_READY, GRPC_ERROR_NONE,
+                                  "connecting_ready");
+      sd->connected_subchannel = GRPC_CONNECTED_SUBCHANNEL_REF(
+          grpc_subchannel_get_connected_subchannel(sd->subchannel),
+          "connected");
+      p->selected = sd;
+      if (GRPC_TRACER_ON(grpc_lb_pick_first_trace)) {
+        gpr_log(GPR_INFO, "Pick First %p selected subchannel %p", (void*)p,
+                (void*)sd->subchannel);
+      }
+      // Drop all other subchannels, since we are now connected.
+      destroy_unselected_subchannels_locked(exec_ctx, p);
+      // Update any calls that were waiting for a pick.
+      pending_pick* pp;
+      while ((pp = p->pending_picks)) {
+        p->pending_picks = pp->next;
+        *pp->target = GRPC_CONNECTED_SUBCHANNEL_REF(
+            p->selected->connected_subchannel, "picked");
         if (GRPC_TRACER_ON(grpc_lb_pick_first_trace)) {
-          gpr_log(GPR_INFO, "Pick First %p selected subchannel %p", (void*)p,
-                  (void*)sd->subchannel);
-        }
-        // Drop all other subchannels, since we are now connected.
-        destroy_unselected_subchannels_locked(exec_ctx, p);
-        // Update any calls that were waiting for a pick.
-        pending_pick* pp;
-        while ((pp = p->pending_picks)) {
-          p->pending_picks = pp->next;
-          *pp->target = GRPC_CONNECTED_SUBCHANNEL_REF(
-              p->selected->connected_subchannel, "picked");
-          if (GRPC_TRACER_ON(grpc_lb_pick_first_trace)) {
-            gpr_log(GPR_INFO,
-                    "Servicing pending pick with selected subchannel %p",
-                    (void*)p->selected);
-          }
-          GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete, GRPC_ERROR_NONE);
-          gpr_free(pp);
+          gpr_log(GPR_INFO,
+                  "Servicing pending pick with selected subchannel %p",
+                  (void*)p->selected);
         }
-        // Renew notification.
-        grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
-        return;
+        GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete, GRPC_ERROR_NONE);
+        gpr_free(pp);
       }
-      case GRPC_CHANNEL_TRANSIENT_FAILURE: {
-        do {
-          sd->subchannel_list->checking_subchannel =
-              (sd->subchannel_list->checking_subchannel + 1) %
-              sd->subchannel_list->num_subchannels;
-          sd = &sd->subchannel_list
-                    ->subchannels[sd->subchannel_list->checking_subchannel];
-        } while (sd->subchannel == NULL);
-        // Case 1: Only set state to TRANSIENT_FAILURE if we've tried
-        // all subchannels.
-        if (sd->subchannel_list->checking_subchannel == 0 &&
-            sd->subchannel_list == p->subchannel_list) {
-          grpc_connectivity_state_set(
-              exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
-              GRPC_ERROR_REF(error), "connecting_transient_failure");
-        }
-        sd->curr_connectivity_state =
-            grpc_subchannel_check_connectivity(sd->subchannel, &error);
-        GRPC_ERROR_UNREF(error);
-        if (sd->curr_connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-          // Reuses the connectivity refs from the previous watch.
-          grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
-          return;
-        }
-        break;  // Go back to top of loop.
+      // Renew notification.
+      grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
+      break;
+    }
+    case GRPC_CHANNEL_TRANSIENT_FAILURE: {
+      grpc_lb_subchannel_data_stop_connectivity_watch(exec_ctx, sd);
+      do {
+        sd->subchannel_list->checking_subchannel =
+            (sd->subchannel_list->checking_subchannel + 1) %
+            sd->subchannel_list->num_subchannels;
+        sd = &sd->subchannel_list
+                  ->subchannels[sd->subchannel_list->checking_subchannel];
+      } while (sd->subchannel == nullptr);
+      // Case 1: Only set state to TRANSIENT_FAILURE if we've tried
+      // all subchannels.
+      if (sd->subchannel_list->checking_subchannel == 0 &&
+          sd->subchannel_list == p->subchannel_list) {
+        grpc_connectivity_state_set(
+            exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
+            GRPC_ERROR_REF(error), "connecting_transient_failure");
       }
-      case GRPC_CHANNEL_CONNECTING:
-      case GRPC_CHANNEL_IDLE: {
-        // Only update connectivity state in case 1.
-        if (sd->subchannel_list == p->subchannel_list) {
-          grpc_connectivity_state_set(
-              exec_ctx, &p->state_tracker, GRPC_CHANNEL_CONNECTING,
-              GRPC_ERROR_REF(error), "connecting_changed");
-        }
-        // Renew notification.
-        grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
-        return;
+      // Reuses the connectivity refs from the previous watch.
+      grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
+      break;
+    }
+    case GRPC_CHANNEL_CONNECTING:
+    case GRPC_CHANNEL_IDLE: {
+      // Only update connectivity state in case 1.
+      if (sd->subchannel_list == p->subchannel_list) {
+        grpc_connectivity_state_set(
+            exec_ctx, &p->state_tracker, GRPC_CHANNEL_CONNECTING,
+            GRPC_ERROR_REF(error), "connecting_changed");
       }
-      case GRPC_CHANNEL_SHUTDOWN: {
-        grpc_lb_subchannel_data_unref_subchannel(exec_ctx, sd,
-                                                 "pf_candidate_shutdown");
-        // Advance to next subchannel and check its state.
-        grpc_lb_subchannel_data* original_sd = sd;
-        do {
-          sd->subchannel_list->checking_subchannel =
-              (sd->subchannel_list->checking_subchannel + 1) %
-              sd->subchannel_list->num_subchannels;
-          sd = &sd->subchannel_list
-                    ->subchannels[sd->subchannel_list->checking_subchannel];
-        } while (sd->subchannel == NULL && sd != original_sd);
-        if (sd == original_sd) {
-          grpc_lb_subchannel_list_unref_for_connectivity_watch(
-              exec_ctx, sd->subchannel_list, "pf_candidate_shutdown");
-          shutdown_locked(exec_ctx, p,
-                          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                              "Pick first exhausted channels", &error, 1));
-          return;
-        }
-        if (sd->subchannel_list == p->subchannel_list) {
-          grpc_connectivity_state_set(
-              exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
-              GRPC_ERROR_REF(error), "subchannel_failed");
-        }
-        sd->curr_connectivity_state =
-            grpc_subchannel_check_connectivity(sd->subchannel, &error);
-        GRPC_ERROR_UNREF(error);
-        if (sd->curr_connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
-          // Reuses the connectivity refs from the previous watch.
-          grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
-          return;
-        }
-        // For any other state, go back to top of loop.
-        // We will reuse the connectivity refs from the previous watch.
+      // Renew notification.
+      grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
+      break;
+    }
+    case GRPC_CHANNEL_SHUTDOWN: {
+      grpc_lb_subchannel_data_stop_connectivity_watch(exec_ctx, sd);
+      grpc_lb_subchannel_data_unref_subchannel(exec_ctx, sd,
+                                               "pf_candidate_shutdown");
+      // Advance to next subchannel and check its state.
+      grpc_lb_subchannel_data* original_sd = sd;
+      do {
+        sd->subchannel_list->checking_subchannel =
+            (sd->subchannel_list->checking_subchannel + 1) %
+            sd->subchannel_list->num_subchannels;
+        sd = &sd->subchannel_list
+                  ->subchannels[sd->subchannel_list->checking_subchannel];
+      } while (sd->subchannel == nullptr && sd != original_sd);
+      if (sd == original_sd) {
+        grpc_lb_subchannel_list_unref_for_connectivity_watch(
+            exec_ctx, sd->subchannel_list, "pf_candidate_shutdown");
+        shutdown_locked(exec_ctx, p,
+                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                            "Pick first exhausted channels", &error, 1));
+        break;
+      }
+      if (sd->subchannel_list == p->subchannel_list) {
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    GRPC_ERROR_REF(error), "subchannel_failed");
       }
+      // Reuses the connectivity refs from the previous watch.
+      grpc_lb_subchannel_data_start_connectivity_watch(exec_ctx, sd);
+      break;
     }
   }
 }
@@ -585,7 +569,7 @@ static void pick_first_factory_unref(grpc_lb_policy_factory* factory) {}
 static grpc_lb_policy* create_pick_first(grpc_exec_ctx* exec_ctx,
                                          grpc_lb_policy_factory* factory,
                                          grpc_lb_policy_args* args) {
-  GPR_ASSERT(args->client_channel_factory != NULL);
+  GPR_ASSERT(args->client_channel_factory != nullptr);
   pick_first_lb_policy* p = (pick_first_lb_policy*)gpr_zalloc(sizeof(*p));
   if (GRPC_TRACER_ON(grpc_lb_pick_first_trace)) {
     gpr_log(GPR_DEBUG, "Pick First %p created.", (void*)p);

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

@@ -100,7 +100,7 @@ typedef struct round_robin_lb_policy {
  * The caller must do that if it returns a pick. */
 static size_t get_next_ready_subchannel_index_locked(
     const round_robin_lb_policy* p) {
-  GPR_ASSERT(p->subchannel_list != NULL);
+  GPR_ASSERT(p->subchannel_list != nullptr);
   if (GRPC_TRACER_ON(grpc_lb_round_robin_trace)) {
     gpr_log(GPR_INFO,
             "[RR %p] getting next ready subchannel (out of %lu), "
@@ -161,8 +161,8 @@ static void rr_destroy(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol) {
     gpr_log(GPR_DEBUG, "[RR %p] Destroying Round Robin policy at %p",
             (void*)pol, (void*)pol);
   }
-  GPR_ASSERT(p->subchannel_list == NULL);
-  GPR_ASSERT(p->latest_pending_subchannel_list == NULL);
+  GPR_ASSERT(p->subchannel_list == nullptr);
+  GPR_ASSERT(p->latest_pending_subchannel_list == nullptr);
   grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker);
   grpc_subchannel_index_unref();
   gpr_free(p);
@@ -175,25 +175,25 @@ static void shutdown_locked(grpc_exec_ctx* exec_ctx, round_robin_lb_policy* p,
   }
   p->shutdown = true;
   pending_pick* pp;
-  while ((pp = p->pending_picks) != NULL) {
+  while ((pp = p->pending_picks) != nullptr) {
     p->pending_picks = pp->next;
-    *pp->target = NULL;
+    *pp->target = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete, GRPC_ERROR_REF(error));
     gpr_free(pp);
   }
   grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
                               GRPC_CHANNEL_SHUTDOWN, GRPC_ERROR_REF(error),
                               "rr_shutdown");
-  if (p->subchannel_list != NULL) {
+  if (p->subchannel_list != nullptr) {
     grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
                                                "sl_shutdown_rr_shutdown");
-    p->subchannel_list = NULL;
+    p->subchannel_list = nullptr;
   }
-  if (p->latest_pending_subchannel_list != NULL) {
+  if (p->latest_pending_subchannel_list != nullptr) {
     grpc_lb_subchannel_list_shutdown_and_unref(
         exec_ctx, p->latest_pending_subchannel_list,
         "sl_shutdown_pending_rr_shutdown");
-    p->latest_pending_subchannel_list = NULL;
+    p->latest_pending_subchannel_list = nullptr;
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -209,11 +209,11 @@ static void rr_cancel_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
                                   grpc_error* error) {
   round_robin_lb_policy* p = (round_robin_lb_policy*)pol;
   pending_pick* pp = p->pending_picks;
-  p->pending_picks = NULL;
-  while (pp != NULL) {
+  p->pending_picks = nullptr;
+  while (pp != nullptr) {
     pending_pick* next = pp->next;
     if (pp->target == target) {
-      *target = NULL;
+      *target = nullptr;
       GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete,
                          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Pick cancelled", &error, 1));
@@ -233,12 +233,12 @@ static void rr_cancel_picks_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
                                    grpc_error* error) {
   round_robin_lb_policy* p = (round_robin_lb_policy*)pol;
   pending_pick* pp = p->pending_picks;
-  p->pending_picks = NULL;
-  while (pp != NULL) {
+  p->pending_picks = nullptr;
+  while (pp != nullptr) {
     pending_pick* next = pp->next;
     if ((pp->initial_metadata_flags & initial_metadata_flags_mask) ==
         initial_metadata_flags_eq) {
-      *pp->target = NULL;
+      *pp->target = nullptr;
       GRPC_CLOSURE_SCHED(exec_ctx, pp->on_complete,
                          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Pick cancelled", &error, 1));
@@ -281,7 +281,7 @@ static int rr_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
             p->shutdown);
   }
   GPR_ASSERT(!p->shutdown);
-  if (p->subchannel_list != NULL) {
+  if (p->subchannel_list != nullptr) {
     const size_t next_ready_index = get_next_ready_subchannel_index_locked(p);
     if (next_ready_index < p->subchannel_list->num_subchannels) {
       /* readily available, report right away */
@@ -289,7 +289,7 @@ static int rr_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
           &p->subchannel_list->subchannels[next_ready_index];
       *target =
           GRPC_CONNECTED_SUBCHANNEL_REF(sd->connected_subchannel, "rr_picked");
-      if (user_data != NULL) {
+      if (user_data != nullptr) {
         *user_data = sd->user_data;
       }
       if (GRPC_TRACER_ON(grpc_lb_round_robin_trace)) {
@@ -472,7 +472,7 @@ static void rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
     }
   } else {  // sd not in SHUTDOWN
     if (sd->curr_connectivity_state == GRPC_CHANNEL_READY) {
-      if (sd->connected_subchannel == NULL) {
+      if (sd->connected_subchannel == nullptr) {
         sd->connected_subchannel = GRPC_CONNECTED_SUBCHANNEL_REF(
             grpc_subchannel_get_connected_subchannel(sd->subchannel),
             "connected");
@@ -486,7 +486,7 @@ static void rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
         GPR_ASSERT(!sd->subchannel_list->shutting_down);
         if (GRPC_TRACER_ON(grpc_lb_round_robin_trace)) {
           const unsigned long num_subchannels =
-              p->subchannel_list != NULL
+              p->subchannel_list != nullptr
                   ? (unsigned long)p->subchannel_list->num_subchannels
                   : 0;
           gpr_log(GPR_DEBUG,
@@ -495,13 +495,13 @@ static void rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
                   (void*)p, (void*)p->subchannel_list, num_subchannels,
                   (void*)sd->subchannel_list, num_subchannels);
         }
-        if (p->subchannel_list != NULL) {
+        if (p->subchannel_list != nullptr) {
           // dispose of the current subchannel_list
           grpc_lb_subchannel_list_shutdown_and_unref(
               exec_ctx, p->subchannel_list, "sl_phase_out_shutdown");
         }
         p->subchannel_list = p->latest_pending_subchannel_list;
-        p->latest_pending_subchannel_list = NULL;
+        p->latest_pending_subchannel_list = nullptr;
       }
       /* at this point we know there's at least one suitable subchannel. Go
        * ahead and pick one and notify the pending suitors in
@@ -510,7 +510,7 @@ static void rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
       GPR_ASSERT(next_ready_index < p->subchannel_list->num_subchannels);
       grpc_lb_subchannel_data* selected =
           &p->subchannel_list->subchannels[next_ready_index];
-      if (p->pending_picks != NULL) {
+      if (p->pending_picks != nullptr) {
         // if the selected subchannel is going to be used for the pending
         // picks, update the last picked pointer
         update_last_ready_subchannel_index_locked(p, next_ready_index);
@@ -520,7 +520,7 @@ static void rr_connectivity_changed_locked(grpc_exec_ctx* exec_ctx, void* arg,
         p->pending_picks = pp->next;
         *pp->target = GRPC_CONNECTED_SUBCHANNEL_REF(
             selected->connected_subchannel, "rr_picked");
-        if (pp->user_data != NULL) {
+        if (pp->user_data != nullptr) {
           *pp->user_data = selected->user_data;
         }
         if (GRPC_TRACER_ON(grpc_lb_round_robin_trace)) {
@@ -577,11 +577,11 @@ static void rr_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
   round_robin_lb_policy* p = (round_robin_lb_policy*)policy;
   const grpc_arg* arg =
       grpc_channel_args_find(args->args, GRPC_ARG_LB_ADDRESSES);
-  if (arg == NULL || arg->type != GRPC_ARG_POINTER) {
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "[RR %p] update provided no addresses; ignoring", p);
     // If we don't have a current subchannel list, go into TRANSIENT_FAILURE.
     // Otherwise, keep using the current subchannel list (ignore this update).
-    if (p->subchannel_list == NULL) {
+    if (p->subchannel_list == nullptr) {
       grpc_connectivity_state_set(
           exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing update in args"),
@@ -602,7 +602,7 @@ static void rr_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
         exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty update"),
         "rr_update_empty");
-    if (p->subchannel_list != NULL) {
+    if (p->subchannel_list != nullptr) {
       grpc_lb_subchannel_list_shutdown_and_unref(exec_ctx, p->subchannel_list,
                                                  "sl_shutdown_empty_update");
     }
@@ -610,7 +610,7 @@ static void rr_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
     return;
   }
   if (p->started_picking) {
-    if (p->latest_pending_subchannel_list != NULL) {
+    if (p->latest_pending_subchannel_list != nullptr) {
       if (GRPC_TRACER_ON(grpc_lb_round_robin_trace)) {
         gpr_log(GPR_DEBUG,
                 "[RR %p] Shutting down latest pending subchannel list %p, "
@@ -635,7 +635,7 @@ static void rr_update_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
   } else {
     // The policy isn't picking yet. Save the update for later, disposing of
     // previous version if any.
-    if (p->subchannel_list != NULL) {
+    if (p->subchannel_list != nullptr) {
       grpc_lb_subchannel_list_shutdown_and_unref(
           exec_ctx, p->subchannel_list, "rr_update_before_started_picking");
     }
@@ -662,7 +662,7 @@ static void round_robin_factory_unref(grpc_lb_policy_factory* factory) {}
 static grpc_lb_policy* round_robin_create(grpc_exec_ctx* exec_ctx,
                                           grpc_lb_policy_factory* factory,
                                           grpc_lb_policy_args* args) {
-  GPR_ASSERT(args->client_channel_factory != NULL);
+  GPR_ASSERT(args->client_channel_factory != nullptr);
   round_robin_lb_policy* p = (round_robin_lb_policy*)gpr_zalloc(sizeof(*p));
   grpc_lb_policy_init(&p->base, &round_robin_lb_policy_vtable, args->combiner);
   grpc_subchannel_index_ref();

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

@@ -31,7 +31,7 @@
 void grpc_lb_subchannel_data_unref_subchannel(grpc_exec_ctx* exec_ctx,
                                               grpc_lb_subchannel_data* sd,
                                               const char* reason) {
-  if (sd->subchannel != NULL) {
+  if (sd->subchannel != nullptr) {
     if (GRPC_TRACER_ON(*sd->subchannel_list->tracer)) {
       gpr_log(GPR_DEBUG,
               "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
@@ -42,16 +42,16 @@ void grpc_lb_subchannel_data_unref_subchannel(grpc_exec_ctx* exec_ctx,
               sd->subchannel_list->num_subchannels, sd->subchannel);
     }
     GRPC_SUBCHANNEL_UNREF(exec_ctx, sd->subchannel, reason);
-    sd->subchannel = NULL;
-    if (sd->connected_subchannel != NULL) {
+    sd->subchannel = nullptr;
+    if (sd->connected_subchannel != nullptr) {
       GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, sd->connected_subchannel,
                                       reason);
-      sd->connected_subchannel = NULL;
+      sd->connected_subchannel = nullptr;
     }
-    if (sd->user_data != NULL) {
-      GPR_ASSERT(sd->user_data_vtable != NULL);
+    if (sd->user_data != nullptr) {
+      GPR_ASSERT(sd->user_data_vtable != nullptr);
       sd->user_data_vtable->destroy(exec_ctx, sd->user_data);
-      sd->user_data = NULL;
+      sd->user_data = nullptr;
     }
   }
 }
@@ -126,7 +126,7 @@ grpc_lb_subchannel_list* grpc_lb_subchannel_list_create(
     grpc_subchannel* subchannel = grpc_client_channel_factory_create_subchannel(
         exec_ctx, args->client_channel_factory, &sc_args);
     grpc_channel_args_destroy(exec_ctx, new_args);
-    if (subchannel == NULL) {
+    if (subchannel == nullptr) {
       // Subchannel could not be created.
       if (GRPC_TRACER_ON(*tracer)) {
         char* address_uri =
@@ -162,7 +162,7 @@ grpc_lb_subchannel_list* grpc_lb_subchannel_list_create(
     sd->curr_connectivity_state = GRPC_CHANNEL_IDLE;
     sd->pending_connectivity_state_unsafe = GRPC_CHANNEL_IDLE;
     sd->user_data_vtable = addresses->user_data_vtable;
-    if (sd->user_data_vtable != NULL) {
+    if (sd->user_data_vtable != nullptr) {
       sd->user_data =
           sd->user_data_vtable->copy(addresses->addresses[i].user_data);
     }
@@ -240,7 +240,8 @@ static void subchannel_data_cancel_connectivity_watch(
             (size_t)(sd - sd->subchannel_list->subchannels),
             sd->subchannel_list->num_subchannels, sd->subchannel, reason);
   }
-  grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, NULL, NULL,
+  grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, nullptr,
+                                         nullptr,
                                          &sd->connectivity_changed_closure);
 }
 
@@ -261,7 +262,7 @@ void grpc_lb_subchannel_list_shutdown_and_unref(
     // Otherwise, unref the subchannel directly.
     if (sd->connectivity_notification_pending) {
       subchannel_data_cancel_connectivity_watch(exec_ctx, sd, reason);
-    } else if (sd->subchannel != NULL) {
+    } else if (sd->subchannel != nullptr) {
       grpc_lb_subchannel_data_unref_subchannel(exec_ctx, sd, reason);
     }
   }

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

@@ -43,11 +43,11 @@ grpc_lb_addresses* grpc_lb_addresses_copy(const grpc_lb_addresses* addresses) {
   memcpy(new_addresses->addresses, addresses->addresses,
          sizeof(grpc_lb_address) * addresses->num_addresses);
   for (size_t i = 0; i < addresses->num_addresses; ++i) {
-    if (new_addresses->addresses[i].balancer_name != NULL) {
+    if (new_addresses->addresses[i].balancer_name != nullptr) {
       new_addresses->addresses[i].balancer_name =
           gpr_strdup(new_addresses->addresses[i].balancer_name);
     }
-    if (new_addresses->addresses[i].user_data != NULL) {
+    if (new_addresses->addresses[i].user_data != nullptr) {
       new_addresses->addresses[i].user_data = addresses->user_data_vtable->copy(
           new_addresses->addresses[i].user_data);
     }
@@ -60,7 +60,7 @@ void grpc_lb_addresses_set_address(grpc_lb_addresses* addresses, size_t index,
                                    bool is_balancer, const char* balancer_name,
                                    void* user_data) {
   GPR_ASSERT(index < addresses->num_addresses);
-  if (user_data != NULL) GPR_ASSERT(addresses->user_data_vtable != NULL);
+  if (user_data != nullptr) GPR_ASSERT(addresses->user_data_vtable != nullptr);
   grpc_lb_address* target = &addresses->addresses[index];
   memcpy(target->address.addr, address, address_len);
   target->address.len = address_len;
@@ -98,12 +98,12 @@ int grpc_lb_addresses_cmp(const grpc_lb_addresses* addresses1,
     if (target1->is_balancer > target2->is_balancer) return 1;
     if (target1->is_balancer < target2->is_balancer) return -1;
     const char* balancer_name1 =
-        target1->balancer_name != NULL ? target1->balancer_name : "";
+        target1->balancer_name != nullptr ? target1->balancer_name : "";
     const char* balancer_name2 =
-        target2->balancer_name != NULL ? target2->balancer_name : "";
+        target2->balancer_name != nullptr ? target2->balancer_name : "";
     retval = strcmp(balancer_name1, balancer_name2);
     if (retval != 0) return retval;
-    if (addresses1->user_data_vtable != NULL) {
+    if (addresses1->user_data_vtable != nullptr) {
       retval = addresses1->user_data_vtable->cmp(target1->user_data,
                                                  target2->user_data);
       if (retval != 0) return retval;
@@ -116,7 +116,7 @@ void grpc_lb_addresses_destroy(grpc_exec_ctx* exec_ctx,
                                grpc_lb_addresses* addresses) {
   for (size_t i = 0; i < addresses->num_addresses; ++i) {
     gpr_free(addresses->addresses[i].balancer_name);
-    if (addresses->addresses[i].user_data != NULL) {
+    if (addresses->addresses[i].user_data != nullptr) {
       addresses->user_data_vtable->destroy(exec_ctx,
                                            addresses->addresses[i].user_data);
     }
@@ -148,8 +148,8 @@ grpc_lb_addresses* grpc_lb_addresses_find_channel_arg(
     const grpc_channel_args* channel_args) {
   const grpc_arg* lb_addresses_arg =
       grpc_channel_args_find(channel_args, GRPC_ARG_LB_ADDRESSES);
-  if (lb_addresses_arg == NULL || lb_addresses_arg->type != GRPC_ARG_POINTER)
-    return NULL;
+  if (lb_addresses_arg == nullptr || lb_addresses_arg->type != GRPC_ARG_POINTER)
+    return nullptr;
   return (grpc_lb_addresses*)lb_addresses_arg->value.pointer.p;
 }
 
@@ -164,6 +164,6 @@ void grpc_lb_policy_factory_unref(grpc_lb_policy_factory* factory) {
 grpc_lb_policy* grpc_lb_policy_factory_create_lb_policy(
     grpc_exec_ctx* exec_ctx, grpc_lb_policy_factory* factory,
     grpc_lb_policy_args* args) {
-  if (factory == NULL) return NULL;
+  if (factory == nullptr) return nullptr;
   return factory->vtable->create_lb_policy(exec_ctx, factory, args);
 }

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

@@ -50,7 +50,7 @@ void grpc_register_lb_policy(grpc_lb_policy_factory* factory) {
 static grpc_lb_policy_factory* lookup_factory(const char* name) {
   int i;
 
-  if (name == NULL) return NULL;
+  if (name == nullptr) return nullptr;
 
   for (i = 0; i < g_number_of_lb_policies; i++) {
     if (0 == gpr_stricmp(name, g_all_of_the_lb_policies[i]->vtable->name)) {
@@ -58,7 +58,7 @@ static grpc_lb_policy_factory* lookup_factory(const char* name) {
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 grpc_lb_policy* grpc_lb_policy_create(grpc_exec_ctx* exec_ctx, const char* name,

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

@@ -75,7 +75,7 @@ bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
     goto done;
   }
   // Parse port.
-  if (port == NULL) {
+  if (port == nullptr) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
     goto done;
   }
@@ -118,7 +118,7 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
   in6->sin6_family = AF_INET6;
   // Handle the RFC6874 syntax for IPv6 zone identifiers.
   char* host_end = (char*)gpr_memrchr(host, '%', strlen(host));
-  if (host_end != NULL) {
+  if (host_end != nullptr) {
     GPR_ASSERT(host_end >= host);
     char host_without_scope[INET6_ADDRSTRLEN];
     size_t host_without_scope_len = (size_t)(host_end - host);
@@ -144,7 +144,7 @@ bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
     }
   }
   // Parse port.
-  if (port == NULL) {
+  if (port == nullptr) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
     goto done;
   }

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

@@ -121,15 +121,15 @@ static void dns_ares_shutdown_locked(grpc_exec_ctx* exec_ctx,
   if (r->have_retry_timer) {
     grpc_timer_cancel(exec_ctx, &r->retry_timer);
   }
-  if (r->pending_request != NULL) {
+  if (r->pending_request != nullptr) {
     grpc_cancel_ares_request(exec_ctx, r->pending_request);
   }
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
@@ -155,7 +155,7 @@ static void dns_ares_on_retry_timer_locked(grpc_exec_ctx* exec_ctx, void* arg,
 }
 
 static bool value_in_json_array(grpc_json* array, const char* value) {
-  for (grpc_json* entry = array->child; entry != NULL; entry = entry->next) {
+  for (grpc_json* entry = array->child; entry != nullptr; entry = entry->next) {
     if (entry->type == GRPC_JSON_STRING && strcmp(entry->value, value) == 0) {
       return true;
     }
@@ -165,47 +165,48 @@ static bool value_in_json_array(grpc_json* array, const char* value) {
 
 static char* choose_service_config(char* service_config_choice_json) {
   grpc_json* choices_json = grpc_json_parse_string(service_config_choice_json);
-  if (choices_json == NULL || choices_json->type != GRPC_JSON_ARRAY) {
+  if (choices_json == nullptr || choices_json->type != GRPC_JSON_ARRAY) {
     gpr_log(GPR_ERROR, "cannot parse service config JSON string");
-    return NULL;
+    return nullptr;
   }
-  char* service_config = NULL;
-  for (grpc_json* choice = choices_json->child; choice != NULL;
+  char* service_config = nullptr;
+  for (grpc_json* choice = choices_json->child; choice != nullptr;
        choice = choice->next) {
     if (choice->type != GRPC_JSON_OBJECT) {
       gpr_log(GPR_ERROR, "cannot parse service config JSON string");
       break;
     }
-    grpc_json* service_config_json = NULL;
-    for (grpc_json* field = choice->child; field != NULL; field = field->next) {
+    grpc_json* service_config_json = nullptr;
+    for (grpc_json* field = choice->child; field != nullptr;
+         field = field->next) {
       // Check client language, if specified.
       if (strcmp(field->key, "clientLanguage") == 0) {
         if (field->type != GRPC_JSON_ARRAY ||
             !value_in_json_array(field, "c++")) {
-          service_config_json = NULL;
+          service_config_json = nullptr;
           break;
         }
       }
       // Check client hostname, if specified.
       if (strcmp(field->key, "clientHostname") == 0) {
         char* hostname = grpc_gethostname();
-        if (hostname == NULL || field->type != GRPC_JSON_ARRAY ||
+        if (hostname == nullptr || field->type != GRPC_JSON_ARRAY ||
             !value_in_json_array(field, hostname)) {
-          service_config_json = NULL;
+          service_config_json = nullptr;
           break;
         }
       }
       // Check percentage, if specified.
       if (strcmp(field->key, "percentage") == 0) {
         if (field->type != GRPC_JSON_NUMBER) {
-          service_config_json = NULL;
+          service_config_json = nullptr;
           break;
         }
         int random_pct = rand() % 100;
         int percentage;
         if (sscanf(field->value, "%d", &percentage) != 1 ||
             random_pct > percentage || percentage == 0) {
-          service_config_json = NULL;
+          service_config_json = nullptr;
           break;
         }
       }
@@ -216,7 +217,7 @@ static char* choose_service_config(char* service_config_choice_json) {
         }
       }
     }
-    if (service_config_json != NULL) {
+    if (service_config_json != nullptr) {
       service_config = grpc_json_dump_to_string(service_config_json, 0);
       break;
     }
@@ -228,33 +229,33 @@ static char* choose_service_config(char* service_config_choice_json) {
 static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
                                         grpc_error* error) {
   ares_dns_resolver* r = (ares_dns_resolver*)arg;
-  grpc_channel_args* result = NULL;
+  grpc_channel_args* result = nullptr;
   GPR_ASSERT(r->resolving);
   r->resolving = false;
-  r->pending_request = NULL;
-  if (r->lb_addresses != NULL) {
+  r->pending_request = nullptr;
+  if (r->lb_addresses != nullptr) {
     static const char* args_to_remove[2];
     size_t num_args_to_remove = 0;
     grpc_arg new_args[3];
     size_t num_args_to_add = 0;
     new_args[num_args_to_add++] =
         grpc_lb_addresses_create_channel_arg(r->lb_addresses);
-    grpc_service_config* service_config = NULL;
-    char* service_config_string = NULL;
-    if (r->service_config_json != NULL) {
+    grpc_service_config* service_config = nullptr;
+    char* service_config_string = nullptr;
+    if (r->service_config_json != nullptr) {
       service_config_string = choose_service_config(r->service_config_json);
       gpr_free(r->service_config_json);
-      if (service_config_string != NULL) {
+      if (service_config_string != nullptr) {
         gpr_log(GPR_INFO, "selected service config choice: %s",
                 service_config_string);
         args_to_remove[num_args_to_remove++] = GRPC_ARG_SERVICE_CONFIG;
         new_args[num_args_to_add++] = grpc_channel_arg_string_create(
             (char*)GRPC_ARG_SERVICE_CONFIG, service_config_string);
         service_config = grpc_service_config_create(service_config_string);
-        if (service_config != NULL) {
+        if (service_config != nullptr) {
           const char* lb_policy_name =
               grpc_service_config_get_lb_policy_name(service_config);
-          if (lb_policy_name != NULL) {
+          if (lb_policy_name != nullptr) {
             args_to_remove[num_args_to_remove++] = GRPC_ARG_LB_POLICY_NAME;
             new_args[num_args_to_add++] = grpc_channel_arg_string_create(
                 (char*)GRPC_ARG_LB_POLICY_NAME, (char*)lb_policy_name);
@@ -265,7 +266,7 @@ static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
     result = grpc_channel_args_copy_and_add_and_remove(
         r->channel_args, args_to_remove, num_args_to_remove, new_args,
         num_args_to_add);
-    if (service_config != NULL) grpc_service_config_destroy(service_config);
+    if (service_config != nullptr) grpc_service_config_destroy(service_config);
     gpr_free(service_config_string);
     grpc_lb_addresses_destroy(exec_ctx, r->lb_addresses);
   } else {
@@ -287,7 +288,7 @@ static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
     grpc_timer_init(exec_ctx, &r->retry_timer, next_try,
                     &r->dns_ares_on_retry_timer_locked);
   }
-  if (r->resolved_result != NULL) {
+  if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->resolved_result);
   }
   r->resolved_result = result;
@@ -318,25 +319,25 @@ static void dns_ares_start_resolving_locked(grpc_exec_ctx* exec_ctx,
   GRPC_RESOLVER_REF(&r->base, "dns-resolving");
   GPR_ASSERT(!r->resolving);
   r->resolving = true;
-  r->lb_addresses = NULL;
-  r->service_config_json = NULL;
+  r->lb_addresses = nullptr;
+  r->service_config_json = nullptr;
   r->pending_request = grpc_dns_lookup_ares(
       exec_ctx, r->dns_server, r->name_to_resolve, r->default_port,
       r->interested_parties, &r->dns_ares_on_resolved_locked, &r->lb_addresses,
       true /* check_grpclb */,
-      r->request_service_config ? &r->service_config_json : NULL);
+      r->request_service_config ? &r->service_config_json : nullptr);
 }
 
 static void dns_ares_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
                                               ares_dns_resolver* r) {
-  if (r->next_completion != NULL &&
+  if (r->next_completion != nullptr &&
       r->resolved_version != r->published_version) {
-    *r->target_result = r->resolved_result == NULL
-                            ? NULL
+    *r->target_result = r->resolved_result == nullptr
+                            ? nullptr
                             : grpc_channel_args_copy(r->resolved_result);
     gpr_log(GPR_DEBUG, "dns_ares_maybe_finish_next_locked");
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
     r->published_version = r->resolved_version;
   }
 }
@@ -344,7 +345,7 @@ static void dns_ares_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
 static void dns_ares_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
   gpr_log(GPR_DEBUG, "dns_ares_destroy");
   ares_dns_resolver* r = (ares_dns_resolver*)gr;
-  if (r->resolved_result != NULL) {
+  if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->resolved_result);
   }
   grpc_pollset_set_destroy(exec_ctx, r->interested_parties);
@@ -376,7 +377,7 @@ static grpc_resolver* dns_ares_create(grpc_exec_ctx* exec_ctx,
   r->request_service_config = !grpc_channel_arg_get_integer(
       arg, (grpc_integer_options){false, false, true});
   r->interested_parties = grpc_pollset_set_create();
-  if (args->pollset_set != NULL) {
+  if (args->pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(exec_ctx, r->interested_parties,
                                      args->pollset_set);
   }
@@ -428,7 +429,7 @@ extern "C" void grpc_resolver_dns_ares_init(void) {
   char* resolver = gpr_getenv("GRPC_DNS_RESOLVER");
   /* TODO(zyc): Turn on c-ares based resolver by default after the address
      sorter and the CNAME support are added. */
-  if (resolver != NULL && gpr_stricmp(resolver, "ares") == 0) {
+  if (resolver != nullptr && gpr_stricmp(resolver, "ares") == 0) {
     grpc_error* error = grpc_ares_init();
     if (error != GRPC_ERROR_NONE) {
       GRPC_LOG_IF_ERROR("ares_library_init() failed", error);
@@ -442,7 +443,7 @@ extern "C" void grpc_resolver_dns_ares_init(void) {
 
 extern "C" void grpc_resolver_dns_ares_shutdown(void) {
   char* resolver = gpr_getenv("GRPC_DNS_RESOLVER");
-  if (resolver != NULL && gpr_stricmp(resolver, "ares") == 0) {
+  if (resolver != nullptr && gpr_stricmp(resolver, "ares") == 0) {
     grpc_ares_cleanup();
   }
   gpr_free(resolver);

src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h

@@ -19,6 +19,7 @@
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
 
+#include <ares.h>
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 

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

@@ -91,7 +91,7 @@ static void grpc_ares_ev_driver_unref(grpc_ares_ev_driver* ev_driver) {
   gpr_log(GPR_DEBUG, "Unref ev_driver %" PRIuPTR, (uintptr_t)ev_driver);
   if (gpr_unref(&ev_driver->refs)) {
     gpr_log(GPR_DEBUG, "destroy ev_driver %" PRIuPTR, (uintptr_t)ev_driver);
-    GPR_ASSERT(ev_driver->fds == NULL);
+    GPR_ASSERT(ev_driver->fds == nullptr);
     gpr_mu_destroy(&ev_driver->mu);
     ares_destroy(ev_driver->channel);
     gpr_free(ev_driver);
@@ -106,7 +106,7 @@ static void fd_node_destroy(grpc_exec_ctx* exec_ctx, fd_node* fdn) {
   /* c-ares library has closed the fd inside grpc_fd. This fd may be picked up
      immediately by another thread, and should not be closed by the following
      grpc_fd_orphan. */
-  grpc_fd_orphan(exec_ctx, fdn->fd, NULL, NULL, true /* already_closed */,
+  grpc_fd_orphan(exec_ctx, fdn->fd, nullptr, nullptr, true /* already_closed */,
                  "c-ares query finished");
   gpr_free(fdn);
 }
@@ -142,7 +142,7 @@ grpc_error* grpc_ares_ev_driver_create(grpc_ares_ev_driver** ev_driver,
   gpr_mu_init(&(*ev_driver)->mu);
   gpr_ref_init(&(*ev_driver)->refs, 1);
   (*ev_driver)->pollset_set = pollset_set;
-  (*ev_driver)->fds = NULL;
+  (*ev_driver)->fds = nullptr;
   (*ev_driver)->working = false;
   (*ev_driver)->shutting_down = false;
   return GRPC_ERROR_NONE;
@@ -165,7 +165,7 @@ void grpc_ares_ev_driver_shutdown(grpc_exec_ctx* exec_ctx,
   gpr_mu_lock(&ev_driver->mu);
   ev_driver->shutting_down = true;
   fd_node* fn = ev_driver->fds;
-  while (fn != NULL) {
+  while (fn != nullptr) {
     grpc_fd_shutdown(
         exec_ctx, fn->fd,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("grpc_ares_ev_driver_shutdown"));
@@ -180,7 +180,7 @@ static fd_node* pop_fd_node(fd_node** head, int fd) {
   fd_node dummy_head;
   dummy_head.next = *head;
   fd_node* node = &dummy_head;
-  while (node->next != NULL) {
+  while (node->next != nullptr) {
     if (grpc_fd_wrapped_fd(node->next->fd) == fd) {
       fd_node* ret = node->next;
       node->next = node->next->next;
@@ -189,7 +189,7 @@ static fd_node* pop_fd_node(fd_node** head, int fd) {
     }
     node = node->next;
   }
-  return NULL;
+  return nullptr;
 }
 
 /* Check if \a fd is still readable */
@@ -275,7 +275,7 @@ ares_channel* grpc_ares_ev_driver_get_channel(grpc_ares_ev_driver* ev_driver) {
 // driver_closure with these filedescriptors.
 static void grpc_ares_notify_on_event_locked(grpc_exec_ctx* exec_ctx,
                                              grpc_ares_ev_driver* ev_driver) {
-  fd_node* new_list = NULL;
+  fd_node* new_list = nullptr;
   if (!ev_driver->shutting_down) {
     ares_socket_t socks[ARES_GETSOCK_MAXNUM];
     int socks_bitmask =
@@ -285,7 +285,7 @@ static void grpc_ares_notify_on_event_locked(grpc_exec_ctx* exec_ctx,
           ARES_GETSOCK_WRITABLE(socks_bitmask, i)) {
         fd_node* fdn = pop_fd_node(&ev_driver->fds, socks[i]);
         // Create a new fd_node if sock[i] is not in the fd_node list.
-        if (fdn == NULL) {
+        if (fdn == nullptr) {
           char* fd_name;
           gpr_asprintf(&fd_name, "ares_ev_driver-%" PRIuPTR, i);
           fdn = (fd_node*)gpr_malloc(sizeof(fd_node));
@@ -332,14 +332,14 @@ static void grpc_ares_notify_on_event_locked(grpc_exec_ctx* exec_ctx,
   // Any remaining fds in ev_driver->fds were not returned by ares_getsock() and
   // are therefore no longer in use, so they can be shut down and removed from
   // the list.
-  while (ev_driver->fds != NULL) {
+  while (ev_driver->fds != nullptr) {
     fd_node* cur = ev_driver->fds;
     ev_driver->fds = ev_driver->fds->next;
     fd_node_shutdown(exec_ctx, cur);
   }
   ev_driver->fds = new_list;
   // If the ev driver has no working fd, all the tasks are done.
-  if (new_list == NULL) {
+  if (new_list == nullptr) {
     ev_driver->working = false;
     gpr_log(GPR_DEBUG, "ev driver stop working");
   }

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

@@ -102,7 +102,7 @@ static void grpc_ares_request_unref(grpc_exec_ctx* exec_ctx,
      request */
   if (gpr_unref(&r->pending_queries)) {
     /* TODO(zyc): Sort results with RFC6724 before invoking on_done. */
-    if (exec_ctx == NULL) {
+    if (exec_ctx == nullptr) {
       /* A new exec_ctx is created here, as the c-ares interface does not
          provide one in ares_host_callback. It's safe to schedule on_done with
          the newly created exec_ctx, since the caller has been warned not to
@@ -150,12 +150,12 @@ static void on_hostbyname_done_cb(void* arg, int status, int timeouts,
     r->error = GRPC_ERROR_NONE;
     r->success = true;
     grpc_lb_addresses** lb_addresses = r->lb_addrs_out;
-    if (*lb_addresses == NULL) {
-      *lb_addresses = grpc_lb_addresses_create(0, NULL);
+    if (*lb_addresses == nullptr) {
+      *lb_addresses = grpc_lb_addresses_create(0, nullptr);
     }
     size_t prev_naddr = (*lb_addresses)->num_addresses;
     size_t i;
-    for (i = 0; hostent->h_addr_list[i] != NULL; i++) {
+    for (i = 0; hostent->h_addr_list[i] != nullptr; i++) {
     }
     (*lb_addresses)->num_addresses += i;
     (*lb_addresses)->addresses = (grpc_lb_address*)gpr_realloc(
@@ -174,8 +174,8 @@ static void on_hostbyname_done_cb(void* arg, int status, int timeouts,
           grpc_lb_addresses_set_address(
               *lb_addresses, i, &addr, addr_len,
               hr->is_balancer /* is_balancer */,
-              hr->is_balancer ? hr->host : NULL /* balancer_name */,
-              NULL /* user_data */);
+              hr->is_balancer ? hr->host : nullptr /* balancer_name */,
+              nullptr /* user_data */);
           char output[INET6_ADDRSTRLEN];
           ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
           gpr_log(GPR_DEBUG,
@@ -195,8 +195,8 @@ static void on_hostbyname_done_cb(void* arg, int status, int timeouts,
           grpc_lb_addresses_set_address(
               *lb_addresses, i, &addr, addr_len,
               hr->is_balancer /* is_balancer */,
-              hr->is_balancer ? hr->host : NULL /* balancer_name */,
-              NULL /* user_data */);
+              hr->is_balancer ? hr->host : nullptr /* balancer_name */,
+              nullptr /* user_data */);
           char output[INET_ADDRSTRLEN];
           ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
           gpr_log(GPR_DEBUG,
@@ -220,7 +220,7 @@ static void on_hostbyname_done_cb(void* arg, int status, int timeouts,
     }
   }
   gpr_mu_unlock(&r->mu);
-  destroy_hostbyname_request(NULL, hr);
+  destroy_hostbyname_request(nullptr, hr);
 }
 
 static void on_srv_query_done_cb(void* arg, int status, int timeouts,
@@ -234,7 +234,7 @@ static void on_srv_query_done_cb(void* arg, int status, int timeouts,
     const int parse_status = ares_parse_srv_reply(abuf, alen, &reply);
     if (parse_status == ARES_SUCCESS) {
       ares_channel* channel = grpc_ares_ev_driver_get_channel(r->ev_driver);
-      for (struct ares_srv_reply* srv_it = reply; srv_it != NULL;
+      for (struct ares_srv_reply* srv_it = reply; srv_it != nullptr;
            srv_it = srv_it->next) {
         if (grpc_ipv6_loopback_available()) {
           grpc_ares_hostbyname_request* hr = create_hostbyname_request(
@@ -249,7 +249,7 @@ static void on_srv_query_done_cb(void* arg, int status, int timeouts,
         grpc_ares_ev_driver_start(&exec_ctx, r->ev_driver);
       }
     }
-    if (reply != NULL) {
+    if (reply != nullptr) {
       ares_free_data(reply);
     }
   } else if (!r->success) {
@@ -276,15 +276,15 @@ static void on_txt_done_cb(void* arg, int status, int timeouts,
   char* error_msg;
   grpc_ares_request* r = (grpc_ares_request*)arg;
   const size_t prefix_len = sizeof(g_service_config_attribute_prefix) - 1;
-  struct ares_txt_ext* result = NULL;
-  struct ares_txt_ext* reply = NULL;
+  struct ares_txt_ext* result = nullptr;
+  struct ares_txt_ext* reply = nullptr;
   grpc_error* error = GRPC_ERROR_NONE;
   gpr_mu_lock(&r->mu);
   if (status != ARES_SUCCESS) goto fail;
   status = ares_parse_txt_reply_ext(buf, len, &reply);
   if (status != ARES_SUCCESS) goto fail;
   // Find service config in TXT record.
-  for (result = reply; result != NULL; result = result->next) {
+  for (result = reply; result != nullptr; result = result->next) {
     if (result->record_start &&
         memcmp(result->txt, g_service_config_attribute_prefix, prefix_len) ==
             0) {
@@ -292,12 +292,12 @@ static void on_txt_done_cb(void* arg, int status, int timeouts,
     }
   }
   // Found a service config record.
-  if (result != NULL) {
+  if (result != nullptr) {
     size_t service_config_len = result->length - prefix_len;
     *r->service_config_json_out = (char*)gpr_malloc(service_config_len + 1);
     memcpy(*r->service_config_json_out, result->txt + prefix_len,
            service_config_len);
-    for (result = result->next; result != NULL && !result->record_start;
+    for (result = result->next; result != nullptr && !result->record_start;
          result = result->next) {
       *r->service_config_json_out = (char*)gpr_realloc(
           *r->service_config_json_out, service_config_len + result->length + 1);
@@ -323,7 +323,7 @@ fail:
   }
 done:
   gpr_mu_unlock(&r->mu);
-  grpc_ares_request_unref(NULL, r);
+  grpc_ares_request_unref(nullptr, r);
 }
 
 static grpc_ares_request* grpc_dns_lookup_ares_impl(
@@ -332,9 +332,9 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
     grpc_closure* on_done, grpc_lb_addresses** addrs, bool check_grpclb,
     char** service_config_json) {
   grpc_error* error = GRPC_ERROR_NONE;
-  grpc_ares_hostbyname_request* hr = NULL;
-  grpc_ares_request* r = NULL;
-  ares_channel* channel = NULL;
+  grpc_ares_hostbyname_request* hr = nullptr;
+  grpc_ares_request* r = nullptr;
+  ares_channel* channel = nullptr;
   /* TODO(zyc): Enable tracing after #9603 is checked in */
   /* if (grpc_dns_trace) {
       gpr_log(GPR_DEBUG, "resolve_address (blocking): name=%s, default_port=%s",
@@ -345,13 +345,13 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
   char* host;
   char* port;
   gpr_split_host_port(name, &host, &port);
-  if (host == NULL) {
+  if (host == nullptr) {
     error = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto error_cleanup;
-  } else if (port == NULL) {
-    if (default_port == NULL) {
+  } else if (port == nullptr) {
+    if (default_port == nullptr) {
       error = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
@@ -375,7 +375,7 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
   channel = grpc_ares_ev_driver_get_channel(r->ev_driver);
 
   // If dns_server is specified, use it.
-  if (dns_server != NULL) {
+  if (dns_server != nullptr) {
     gpr_log(GPR_INFO, "Using DNS server %s", dns_server);
     grpc_resolved_address addr;
     if (grpc_parse_ipv4_hostport(dns_server, &addr, false /* log_errors */)) {
@@ -429,7 +429,7 @@ static grpc_ares_request* grpc_dns_lookup_ares_impl(
                r);
     gpr_free(service_name);
   }
-  if (service_config_json != NULL) {
+  if (service_config_json != nullptr) {
     grpc_ares_request_ref(r);
     ares_search(*channel, hr->host, ns_c_in, ns_t_txt, on_txt_done_cb, r);
   }
@@ -444,7 +444,7 @@ error_cleanup:
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
   gpr_free(host);
   gpr_free(port);
-  return NULL;
+  return nullptr;
 }
 
 grpc_ares_request* (*grpc_dns_lookup_ares)(
@@ -503,8 +503,8 @@ static void on_dns_lookup_done_cb(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_resolve_address_ares_request* r =
       (grpc_resolve_address_ares_request*)arg;
   grpc_resolved_addresses** resolved_addresses = r->addrs_out;
-  if (r->lb_addrs == NULL || r->lb_addrs->num_addresses == 0) {
-    *resolved_addresses = NULL;
+  if (r->lb_addrs == nullptr || r->lb_addrs->num_addresses == 0) {
+    *resolved_addresses = nullptr;
   } else {
     *resolved_addresses =
         (grpc_resolved_addresses*)gpr_zalloc(sizeof(grpc_resolved_addresses));
@@ -536,10 +536,10 @@ static void grpc_resolve_address_ares_impl(grpc_exec_ctx* exec_ctx,
   r->on_resolve_address_done = on_done;
   GRPC_CLOSURE_INIT(&r->on_dns_lookup_done, on_dns_lookup_done_cb, r,
                     grpc_schedule_on_exec_ctx);
-  grpc_dns_lookup_ares(exec_ctx, NULL /* dns_server */, name, default_port,
+  grpc_dns_lookup_ares(exec_ctx, nullptr /* dns_server */, name, default_port,
                        interested_parties, &r->on_dns_lookup_done, &r->lb_addrs,
                        false /* check_grpclb */,
-                       NULL /* service_config_json */);
+                       nullptr /* service_config_json */);
 }
 
 void (*grpc_resolve_address_ares)(

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

@@ -100,12 +100,12 @@ static void dns_shutdown_locked(grpc_exec_ctx* exec_ctx,
   if (r->have_retry_timer) {
     grpc_timer_cancel(exec_ctx, &r->retry_timer);
   }
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
@@ -150,20 +150,20 @@ static void dns_on_retry_timer_locked(grpc_exec_ctx* exec_ctx, void* arg,
 static void dns_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
                                    grpc_error* error) {
   dns_resolver* r = (dns_resolver*)arg;
-  grpc_channel_args* result = NULL;
+  grpc_channel_args* result = nullptr;
   GPR_ASSERT(r->resolving);
   r->resolving = false;
   GRPC_ERROR_REF(error);
   error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
                              grpc_slice_from_copied_string(r->name_to_resolve));
-  if (r->addresses != NULL) {
+  if (r->addresses != nullptr) {
     grpc_lb_addresses* addresses = grpc_lb_addresses_create(
-        r->addresses->naddrs, NULL /* user_data_vtable */);
+        r->addresses->naddrs, nullptr /* user_data_vtable */);
     for (size_t i = 0; i < r->addresses->naddrs; ++i) {
       grpc_lb_addresses_set_address(
           addresses, i, &r->addresses->addrs[i].addr,
           r->addresses->addrs[i].len, false /* is_balancer */,
-          NULL /* balancer_name */, NULL /* user_data */);
+          nullptr /* balancer_name */, nullptr /* user_data */);
     }
     grpc_arg new_arg = grpc_lb_addresses_create_channel_arg(addresses);
     result = grpc_channel_args_copy_and_add(r->channel_args, &new_arg, 1);
@@ -187,7 +187,7 @@ static void dns_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
                       grpc_combiner_scheduler(r->base.combiner));
     grpc_timer_init(exec_ctx, &r->retry_timer, next_try, &r->on_retry);
   }
-  if (r->resolved_result != NULL) {
+  if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->resolved_result);
   }
   r->resolved_result = result;
@@ -203,7 +203,7 @@ static void dns_start_resolving_locked(grpc_exec_ctx* exec_ctx,
   GRPC_RESOLVER_REF(&r->base, "dns-resolving");
   GPR_ASSERT(!r->resolving);
   r->resolving = true;
-  r->addresses = NULL;
+  r->addresses = nullptr;
   grpc_resolve_address(
       exec_ctx, r->name_to_resolve, r->default_port, r->interested_parties,
       GRPC_CLOSURE_CREATE(dns_on_resolved_locked, r,
@@ -213,20 +213,20 @@ static void dns_start_resolving_locked(grpc_exec_ctx* exec_ctx,
 
 static void dns_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
                                          dns_resolver* r) {
-  if (r->next_completion != NULL &&
+  if (r->next_completion != nullptr &&
       r->resolved_version != r->published_version) {
-    *r->target_result = r->resolved_result == NULL
-                            ? NULL
+    *r->target_result = r->resolved_result == nullptr
+                            ? nullptr
                             : grpc_channel_args_copy(r->resolved_result);
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
     r->published_version = r->resolved_version;
   }
 }
 
 static void dns_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
   dns_resolver* r = (dns_resolver*)gr;
-  if (r->resolved_result != NULL) {
+  if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->resolved_result);
   }
   grpc_pollset_set_destroy(exec_ctx, r->interested_parties);
@@ -241,7 +241,7 @@ static grpc_resolver* dns_create(grpc_exec_ctx* exec_ctx,
                                  const char* default_port) {
   if (0 != strcmp(args->uri->authority, "")) {
     gpr_log(GPR_ERROR, "authority based dns uri's not supported");
-    return NULL;
+    return nullptr;
   }
   // Get name from args.
   char* path = args->uri->path;
@@ -253,7 +253,7 @@ static grpc_resolver* dns_create(grpc_exec_ctx* exec_ctx,
   r->default_port = gpr_strdup(default_port);
   r->channel_args = grpc_channel_args_copy(args->args);
   r->interested_parties = grpc_pollset_set_create();
-  if (args->pollset_set != NULL) {
+  if (args->pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(exec_ctx, r->interested_parties,
                                      args->pollset_set);
   }
@@ -297,13 +297,13 @@ static grpc_resolver_factory* dns_resolver_factory_create() {
 
 extern "C" void grpc_resolver_dns_native_init(void) {
   char* resolver = gpr_getenv("GRPC_DNS_RESOLVER");
-  if (resolver != NULL && gpr_stricmp(resolver, "native") == 0) {
+  if (resolver != nullptr && gpr_stricmp(resolver, "native") == 0) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
     grpc_register_resolver_type(dns_resolver_factory_create());
   } else {
     grpc_resolver_factory* existing_factory =
         grpc_resolver_factory_lookup("dns");
-    if (existing_factory == NULL) {
+    if (existing_factory == nullptr) {
       gpr_log(GPR_DEBUG, "Using native dns resolver");
       grpc_register_resolver_type(dns_resolver_factory_create());
     } else {

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

@@ -78,31 +78,31 @@ static void fake_resolver_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
 static void fake_resolver_shutdown_locked(grpc_exec_ctx* exec_ctx,
                                           grpc_resolver* resolver) {
   fake_resolver* r = (fake_resolver*)resolver;
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
 static void fake_resolver_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
                                                    fake_resolver* r) {
-  if (r->next_completion != NULL && r->next_results != NULL) {
+  if (r->next_completion != nullptr && r->next_results != nullptr) {
     *r->target_result =
         grpc_channel_args_union(r->next_results, r->channel_args);
     grpc_channel_args_destroy(exec_ctx, r->next_results);
-    r->next_results = NULL;
+    r->next_results = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
 static void fake_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
                                                    grpc_resolver* resolver) {
   fake_resolver* r = (fake_resolver*)resolver;
-  if (r->next_results == NULL && r->results_upon_error != NULL) {
+  if (r->next_results == nullptr && r->results_upon_error != nullptr) {
     // Pretend we re-resolved.
     r->next_results = grpc_channel_args_copy(r->results_upon_error);
   }
@@ -162,11 +162,11 @@ static void set_response_closure_fn(grpc_exec_ctx* exec_ctx, void* arg,
   set_response_closure_arg* closure_arg = (set_response_closure_arg*)arg;
   grpc_fake_resolver_response_generator* generator = closure_arg->generator;
   fake_resolver* r = generator->resolver;
-  if (r->next_results != NULL) {
+  if (r->next_results != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->next_results);
   }
   r->next_results = closure_arg->next_response;
-  if (r->results_upon_error != NULL) {
+  if (r->results_upon_error != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->results_upon_error);
   }
   r->results_upon_error = grpc_channel_args_copy(closure_arg->next_response);
@@ -177,7 +177,7 @@ static void set_response_closure_fn(grpc_exec_ctx* exec_ctx, void* arg,
 void grpc_fake_resolver_response_generator_set_response(
     grpc_exec_ctx* exec_ctx, grpc_fake_resolver_response_generator* generator,
     grpc_channel_args* next_response) {
-  GPR_ASSERT(generator->resolver != NULL);
+  GPR_ASSERT(generator->resolver != nullptr);
   set_response_closure_arg* closure_arg =
       (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg));
   closure_arg->generator = generator;
@@ -220,7 +220,7 @@ grpc_fake_resolver_response_generator*
 grpc_fake_resolver_get_response_generator(const grpc_channel_args* args) {
   const grpc_arg* arg =
       grpc_channel_args_find(args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
-  if (arg == NULL || arg->type != GRPC_ARG_POINTER) return NULL;
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
   return (grpc_fake_resolver_response_generator*)arg->value.pointer.p;
 }
 
@@ -240,7 +240,7 @@ static grpc_resolver* fake_resolver_create(grpc_exec_ctx* exec_ctx,
   grpc_resolver_init(&r->base, &fake_resolver_vtable, args->combiner);
   grpc_fake_resolver_response_generator* response_generator =
       grpc_fake_resolver_get_response_generator(args->args);
-  if (response_generator != NULL) response_generator->resolver = r;
+  if (response_generator != nullptr) response_generator->resolver = r;
   return &r->base;
 }
 

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

@@ -71,12 +71,12 @@ static const grpc_resolver_vtable sockaddr_resolver_vtable = {
 static void sockaddr_shutdown_locked(grpc_exec_ctx* exec_ctx,
                                      grpc_resolver* resolver) {
   sockaddr_resolver* r = (sockaddr_resolver*)resolver;
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
@@ -100,13 +100,13 @@ static void sockaddr_next_locked(grpc_exec_ctx* exec_ctx,
 
 static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
                                               sockaddr_resolver* r) {
-  if (r->next_completion != NULL && !r->published) {
+  if (r->next_completion != nullptr && !r->published) {
     r->published = true;
     grpc_arg arg = grpc_lb_addresses_create_channel_arg(r->addresses);
     *r->target_result =
         grpc_channel_args_copy_and_add(r->channel_args, &arg, 1);
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
@@ -149,7 +149,7 @@ static grpc_resolver* sockaddr_create(grpc_exec_ctx* exec_ctx,
   if (0 != strcmp(args->uri->authority, "")) {
     gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme",
             args->uri->scheme);
-    return NULL;
+    return nullptr;
   }
   /* Construct addresses. */
   grpc_slice path_slice =
@@ -157,8 +157,8 @@ static grpc_resolver* sockaddr_create(grpc_exec_ctx* exec_ctx,
   grpc_slice_buffer path_parts;
   grpc_slice_buffer_init(&path_parts);
   grpc_slice_split(path_slice, ",", &path_parts);
-  grpc_lb_addresses* addresses =
-      grpc_lb_addresses_create(path_parts.count, NULL /* user_data_vtable */);
+  grpc_lb_addresses* addresses = grpc_lb_addresses_create(
+      path_parts.count, nullptr /* user_data_vtable */);
   bool errors_found = false;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_uri ith_uri = *args->uri;
@@ -174,7 +174,7 @@ static grpc_resolver* sockaddr_create(grpc_exec_ctx* exec_ctx,
   grpc_slice_unref_internal(exec_ctx, path_slice);
   if (errors_found) {
     grpc_lb_addresses_destroy(exec_ctx, addresses);
-    return NULL;
+    return nullptr;
   }
   /* Instantiate resolver. */
   sockaddr_resolver* r =

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

@@ -30,12 +30,12 @@ void grpc_resolver_factory_unref(grpc_resolver_factory* factory) {
 grpc_resolver* grpc_resolver_factory_create_resolver(
     grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
     grpc_resolver_args* args) {
-  if (factory == NULL) return NULL;
+  if (factory == nullptr) return nullptr;
   return factory->vtable->create_resolver(exec_ctx, factory, args);
 }
 
 char* grpc_resolver_factory_get_default_authority(
     grpc_resolver_factory* factory, grpc_uri* uri) {
-  if (factory == NULL) return NULL;
+  if (factory == nullptr) return nullptr;
   return factory->vtable->get_default_authority(factory, uri);
 }

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

@@ -78,7 +78,7 @@ static grpc_resolver_factory* lookup_factory(const char* name) {
       return g_all_of_the_resolvers[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 grpc_resolver_factory* grpc_resolver_factory_lookup(const char* name) {
@@ -88,7 +88,7 @@ grpc_resolver_factory* grpc_resolver_factory_lookup(const char* name) {
 }
 
 static grpc_resolver_factory* lookup_factory_by_uri(grpc_uri* uri) {
-  if (!uri) return NULL;
+  if (!uri) return nullptr;
   return lookup_factory(uri->scheme);
 }
 
@@ -96,17 +96,17 @@ static grpc_resolver_factory* resolve_factory(grpc_exec_ctx* exec_ctx,
                                               const char* target,
                                               grpc_uri** uri,
                                               char** canonical_target) {
-  grpc_resolver_factory* factory = NULL;
+  grpc_resolver_factory* factory = nullptr;
 
-  GPR_ASSERT(uri != NULL);
+  GPR_ASSERT(uri != nullptr);
   *uri = grpc_uri_parse(exec_ctx, target, 1);
   factory = lookup_factory_by_uri(*uri);
-  if (factory == NULL) {
+  if (factory == nullptr) {
     grpc_uri_destroy(*uri);
     gpr_asprintf(canonical_target, "%s%s", g_default_resolver_prefix, target);
     *uri = grpc_uri_parse(exec_ctx, *canonical_target, 1);
     factory = lookup_factory_by_uri(*uri);
-    if (factory == NULL) {
+    if (factory == nullptr) {
       grpc_uri_destroy(grpc_uri_parse(exec_ctx, target, 0));
       grpc_uri_destroy(grpc_uri_parse(exec_ctx, *canonical_target, 0));
       gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
@@ -120,8 +120,8 @@ grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
                                     const grpc_channel_args* args,
                                     grpc_pollset_set* pollset_set,
                                     grpc_combiner* combiner) {
-  grpc_uri* uri = NULL;
-  char* canonical_target = NULL;
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
   grpc_resolver_factory* factory =
       resolve_factory(exec_ctx, target, &uri, &canonical_target);
   grpc_resolver* resolver;
@@ -139,8 +139,8 @@ grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
 }
 
 char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target) {
-  grpc_uri* uri = NULL;
-  char* canonical_target = NULL;
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
   grpc_resolver_factory* factory =
       resolve_factory(exec_ctx, target, &uri, &canonical_target);
   char* authority = grpc_resolver_factory_get_default_authority(factory, uri);
@@ -151,9 +151,9 @@ char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target) {
 
 char* grpc_resolver_factory_add_default_prefix_if_needed(
     grpc_exec_ctx* exec_ctx, const char* target) {
-  grpc_uri* uri = NULL;
-  char* canonical_target = NULL;
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
   resolve_factory(exec_ctx, target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return canonical_target == NULL ? gpr_strdup(target) : canonical_target;
+  return canonical_target == nullptr ? gpr_strdup(target) : canonical_target;
 }

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

@@ -48,7 +48,7 @@ static void get_replacement_throttle_data_if_needed(
     grpc_server_retry_throttle_data* new_throttle_data =
         (grpc_server_retry_throttle_data*)gpr_atm_acq_load(
             &(*throttle_data)->replacement);
-    if (new_throttle_data == NULL) return;
+    if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
 }
@@ -88,7 +88,7 @@ void grpc_server_retry_throttle_data_unref(
     grpc_server_retry_throttle_data* replacement =
         (grpc_server_retry_throttle_data*)gpr_atm_acq_load(
             &throttle_data->replacement);
-    if (replacement != NULL) {
+    if (replacement != nullptr) {
       grpc_server_retry_throttle_data_unref(replacement);
     }
     gpr_free(throttle_data);
@@ -109,7 +109,7 @@ static grpc_server_retry_throttle_data* grpc_server_retry_throttle_data_create(
   // the token count by scaling proportionately to the old data.  This
   // ensures that if we're already throttling retries on the old scale,
   // we will start out doing the same thing on the new one.
-  if (old_throttle_data != NULL) {
+  if (old_throttle_data != nullptr) {
     double token_fraction =
         (int)gpr_atm_acq_load(&old_throttle_data->milli_tokens) /
         (double)old_throttle_data->max_milli_tokens;
@@ -119,7 +119,7 @@ static grpc_server_retry_throttle_data* grpc_server_retry_throttle_data_create(
                     (gpr_atm)initial_milli_tokens);
   // If there was a pre-existing entry, mark it as stale and give it a
   // pointer to the new entry, which is its replacement.
-  if (old_throttle_data != NULL) {
+  if (old_throttle_data != nullptr) {
     grpc_server_retry_throttle_data_ref(throttle_data);
     gpr_atm_rel_store(&old_throttle_data->replacement, (gpr_atm)throttle_data);
   }
@@ -170,7 +170,7 @@ void grpc_retry_throttle_map_init() {
 
 void grpc_retry_throttle_map_shutdown() {
   gpr_mu_destroy(&g_mu);
-  gpr_avl_unref(g_avl, NULL);
+  gpr_avl_unref(g_avl, nullptr);
 }
 
 grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
@@ -178,12 +178,12 @@ grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
   gpr_mu_lock(&g_mu);
   grpc_server_retry_throttle_data* throttle_data =
       (grpc_server_retry_throttle_data*)gpr_avl_get(g_avl, (char*)server_name,
-                                                    NULL);
-  if (throttle_data == NULL) {
+                                                    nullptr);
+  if (throttle_data == nullptr) {
     // Entry not found.  Create a new one.
     throttle_data = grpc_server_retry_throttle_data_create(
-        max_milli_tokens, milli_token_ratio, NULL);
-    g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, NULL);
+        max_milli_tokens, milli_token_ratio, nullptr);
+    g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, nullptr);
   } else {
     if (throttle_data->max_milli_tokens != max_milli_tokens ||
         throttle_data->milli_token_ratio != milli_token_ratio) {
@@ -191,7 +191,7 @@ grpc_server_retry_throttle_data* grpc_retry_throttle_map_get_data_for_server(
       // the original one.
       throttle_data = grpc_server_retry_throttle_data_create(
           max_milli_tokens, milli_token_ratio, throttle_data);
-      g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, NULL);
+      g_avl = gpr_avl_add(g_avl, (char*)server_name, throttle_data, nullptr);
     } else {
       // Entry found.  Increase refcount.
       grpc_server_retry_throttle_data_ref(throttle_data);

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

@@ -227,7 +227,7 @@ grpc_subchannel* grpc_subchannel_weak_ref(
 
 grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
     grpc_subchannel* c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
-  if (!c) return NULL;
+  if (!c) return nullptr;
   for (;;) {
     gpr_atm old_refs = gpr_atm_acq_load(&c->ref_pair);
     if (old_refs >= (1 << INTERNAL_REF_BITS)) {
@@ -236,7 +236,7 @@ grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
         return c;
       }
     } else {
-      return NULL;
+      return nullptr;
     }
   }
 }
@@ -251,7 +251,7 @@ static void disconnect(grpc_exec_ctx* exec_ctx, grpc_subchannel* c) {
       exec_ctx, c->connector,
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Subchannel disconnected"));
   con = GET_CONNECTED_SUBCHANNEL(c, no_barrier);
-  if (con != NULL) {
+  if (con != nullptr) {
     GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, con, "connection");
     gpr_atm_no_barrier_store(&c->connected_subchannel, (gpr_atm)0xdeadbeef);
   }
@@ -306,17 +306,17 @@ grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
     memcpy((void*)c->filters, args->filters,
            sizeof(grpc_channel_filter*) * c->num_filters);
   } else {
-    c->filters = NULL;
+    c->filters = nullptr;
   }
   c->pollset_set = grpc_pollset_set_create();
   grpc_resolved_address* addr =
       (grpc_resolved_address*)gpr_malloc(sizeof(*addr));
   grpc_get_subchannel_address_arg(exec_ctx, args->args, addr);
-  grpc_resolved_address* new_address = NULL;
-  grpc_channel_args* new_args = NULL;
+  grpc_resolved_address* new_address = nullptr;
+  grpc_channel_args* new_args = nullptr;
   if (grpc_proxy_mappers_map_address(exec_ctx, addr, args->args, &new_address,
                                      &new_args)) {
-    GPR_ASSERT(new_address != NULL);
+    GPR_ASSERT(new_address != nullptr);
     gpr_free(addr);
     addr = new_address;
   }
@@ -324,10 +324,10 @@ grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
   grpc_arg new_arg = grpc_create_subchannel_address_arg(addr);
   gpr_free(addr);
   c->args = grpc_channel_args_copy_and_add_and_remove(
-      new_args != NULL ? new_args : args->args, keys_to_remove,
+      new_args != nullptr ? new_args : args->args, keys_to_remove,
       GPR_ARRAY_SIZE(keys_to_remove), &new_arg, 1);
   gpr_free(new_arg.value.string);
-  if (new_args != NULL) grpc_channel_args_destroy(exec_ctx, new_args);
+  if (new_args != nullptr) grpc_channel_args_destroy(exec_ctx, new_args);
   c->root_external_state_watcher.next = c->root_external_state_watcher.prev =
       &c->root_external_state_watcher;
   GRPC_CLOSURE_INIT(&c->connected, subchannel_connected, c,
@@ -404,7 +404,7 @@ static void on_external_state_watcher_done(grpc_exec_ctx* exec_ctx, void* arg,
                                            grpc_error* error) {
   external_state_watcher* w = (external_state_watcher*)arg;
   grpc_closure* follow_up = w->notify;
-  if (w->pollset_set != NULL) {
+  if (w->pollset_set != nullptr) {
     grpc_pollset_set_del_pollset_set(exec_ctx, w->subchannel->pollset_set,
                                      w->pollset_set);
   }
@@ -451,7 +451,7 @@ static void maybe_start_connecting_locked(grpc_exec_ctx* exec_ctx,
     return;
   }
 
-  if (GET_CONNECTED_SUBCHANNEL(c, no_barrier) != NULL) {
+  if (GET_CONNECTED_SUBCHANNEL(c, no_barrier) != nullptr) {
     /* Already connected: don't restart */
     return;
   }
@@ -490,13 +490,13 @@ void grpc_subchannel_notify_on_state_change(
     grpc_closure* notify) {
   external_state_watcher* w;
 
-  if (state == NULL) {
+  if (state == nullptr) {
     gpr_mu_lock(&c->mu);
     for (w = c->root_external_state_watcher.next;
          w != &c->root_external_state_watcher; w = w->next) {
       if (w->notify == notify) {
         grpc_connectivity_state_notify_on_state_change(
-            exec_ctx, &c->state_tracker, NULL, &w->closure);
+            exec_ctx, &c->state_tracker, nullptr, &w->closure);
       }
     }
     gpr_mu_unlock(&c->mu);
@@ -507,7 +507,7 @@ void grpc_subchannel_notify_on_state_change(
     w->notify = notify;
     GRPC_CLOSURE_INIT(&w->closure, on_external_state_watcher_done, w,
                       grpc_schedule_on_exec_ctx);
-    if (interested_parties != NULL) {
+    if (interested_parties != nullptr) {
       grpc_pollset_set_add_pollset_set(exec_ctx, c->pollset_set,
                                        interested_parties);
     }
@@ -549,10 +549,10 @@ static void subchannel_on_child_state_changed(grpc_exec_ctx* exec_ctx, void* p,
                               "reflect_child");
   if (sw->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
     grpc_connected_subchannel_notify_on_state_change(
-        exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), NULL,
+        exec_ctx, GET_CONNECTED_SUBCHANNEL(c, no_barrier), nullptr,
         &sw->connectivity_state, &sw->closure);
     GRPC_SUBCHANNEL_WEAK_REF(c, "state_watcher");
-    sw = NULL;
+    sw = nullptr;
   }
 
   gpr_mu_unlock(mu);
@@ -565,7 +565,7 @@ static void connected_subchannel_state_op(grpc_exec_ctx* exec_ctx,
                                           grpc_pollset_set* interested_parties,
                                           grpc_connectivity_state* state,
                                           grpc_closure* closure) {
-  grpc_transport_op* op = grpc_make_transport_op(NULL);
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
   grpc_channel_element* elem;
   op->connectivity_state = state;
   op->on_connectivity_state_change = closure;
@@ -585,7 +585,7 @@ void grpc_connected_subchannel_notify_on_state_change(
 void grpc_connected_subchannel_ping(grpc_exec_ctx* exec_ctx,
                                     grpc_connected_subchannel* con,
                                     grpc_closure* closure) {
-  grpc_transport_op* op = grpc_make_transport_op(NULL);
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
   grpc_channel_element* elem;
   op->send_ping = closure;
   elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(con), 0);
@@ -611,7 +611,7 @@ static bool publish_transport_locked(grpc_exec_ctx* exec_ctx,
     return false;
   }
   grpc_error* error = grpc_channel_stack_builder_finish(
-      exec_ctx, builder, 0, 1, connection_destroy, NULL, (void**)&con);
+      exec_ctx, builder, 0, 1, connection_destroy, nullptr, (void**)&con);
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_destroy(exec_ctx, c->connecting_result.transport);
     gpr_log(GPR_ERROR, "error initializing subchannel stack: %s",
@@ -666,7 +666,7 @@ static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* arg,
   GRPC_SUBCHANNEL_WEAK_REF(c, "connected");
   gpr_mu_lock(&c->mu);
   c->connecting = false;
-  if (c->connecting_result.transport != NULL &&
+  if (c->connecting_result.transport != nullptr &&
       publish_transport_locked(exec_ctx, c)) {
     /* do nothing, transport was published */
   } else if (c->disconnected) {
@@ -697,10 +697,10 @@ static void subchannel_connected(grpc_exec_ctx* exec_ctx, void* arg,
 static void subchannel_call_destroy(grpc_exec_ctx* exec_ctx, void* call,
                                     grpc_error* error) {
   grpc_subchannel_call* c = (grpc_subchannel_call*)call;
-  GPR_ASSERT(c->schedule_closure_after_destroy != NULL);
+  GPR_ASSERT(c->schedule_closure_after_destroy != nullptr);
   GPR_TIMER_BEGIN("grpc_subchannel_call_unref.destroy", 0);
   grpc_connected_subchannel* connection = c->connection;
-  grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), NULL,
+  grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c), nullptr,
                           c->schedule_closure_after_destroy);
   GRPC_CONNECTED_SUBCHANNEL_UNREF(exec_ctx, connection, "subchannel_call");
   GPR_TIMER_END("grpc_subchannel_call_unref.destroy", 0);
@@ -708,8 +708,8 @@ static void subchannel_call_destroy(grpc_exec_ctx* exec_ctx, void* call,
 
 void grpc_subchannel_call_set_cleanup_closure(grpc_subchannel_call* call,
                                               grpc_closure* closure) {
-  GPR_ASSERT(call->schedule_closure_after_destroy == NULL);
-  GPR_ASSERT(closure != NULL);
+  GPR_ASSERT(call->schedule_closure_after_destroy == nullptr);
+  GPR_ASSERT(closure != nullptr);
   call->schedule_closure_after_destroy = closure;
 }
 
@@ -756,7 +756,7 @@ grpc_error* grpc_connected_subchannel_create_call(
   (*call)->connection = GRPC_CONNECTED_SUBCHANNEL_REF(con, "subchannel_call");
   const grpc_call_element_args call_args = {
       callstk,            /* call_stack */
-      NULL,               /* server_transport_data */
+      nullptr,            /* server_transport_data */
       args->context,      /* context */
       args->path,         /* path */
       args->start_time,   /* start_time */
@@ -783,7 +783,7 @@ grpc_call_stack* grpc_subchannel_call_get_call_stack(
 static void grpc_uri_to_sockaddr(grpc_exec_ctx* exec_ctx, const char* uri_str,
                                  grpc_resolved_address* addr) {
   grpc_uri* uri = grpc_uri_parse(exec_ctx, uri_str, 0 /* suppress_errors */);
-  GPR_ASSERT(uri != NULL);
+  GPR_ASSERT(uri != nullptr);
   if (!grpc_parse_uri(uri, addr)) memset(addr, 0, sizeof(*addr));
   grpc_uri_destroy(uri);
 }
@@ -801,7 +801,7 @@ void grpc_get_subchannel_address_arg(grpc_exec_ctx* exec_ctx,
 const char* grpc_get_subchannel_address_uri_arg(const grpc_channel_args* args) {
   const grpc_arg* addr_arg =
       grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_ADDRESS);
-  GPR_ASSERT(addr_arg != NULL);  // Should have been set by LB policy.
+  GPR_ASSERT(addr_arg != nullptr);  // Should have been set by LB policy.
   GPR_ASSERT(addr_arg->type == GRPC_ARG_STRING);
   return addr_arg->value.string;
 }

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

@@ -53,7 +53,7 @@ static grpc_subchannel_key* create_key(
     memcpy((grpc_channel_filter*)k->args.filters, args->filters,
            sizeof(*k->args.filters) * k->args.filter_count);
   } else {
-    k->args.filters = NULL;
+    k->args.filters = nullptr;
   }
   k->args.args = copy_channel_args(args->args);
   return k;
@@ -162,10 +162,10 @@ grpc_subchannel* grpc_subchannel_index_find(grpc_exec_ctx* exec_ctx,
 grpc_subchannel* grpc_subchannel_index_register(grpc_exec_ctx* exec_ctx,
                                                 grpc_subchannel_key* key,
                                                 grpc_subchannel* constructed) {
-  grpc_subchannel* c = NULL;
+  grpc_subchannel* c = nullptr;
   bool need_to_unref_constructed;
 
-  while (c == NULL) {
+  while (c == nullptr) {
     need_to_unref_constructed = false;
 
     // Compare and swap loop:
@@ -176,10 +176,10 @@ grpc_subchannel* grpc_subchannel_index_register(grpc_exec_ctx* exec_ctx,
 
     // - Check to see if a subchannel already exists
     c = (grpc_subchannel*)gpr_avl_get(index, key, exec_ctx);
-    if (c != NULL) {
+    if (c != nullptr) {
       c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(c, "index_register");
     }
-    if (c != NULL) {
+    if (c != nullptr) {
       // yes -> we're done
       need_to_unref_constructed = true;
     } else {

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

@@ -52,7 +52,7 @@ static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
     gpr_free(line_prefix);
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /** Returns a copy of percent decoded \a src[begin, end) */
@@ -148,10 +148,10 @@ static int parse_fragment_or_query(const char* uri_text, size_t* i) {
 static void parse_query_parts(grpc_uri* uri) {
   static const char* QUERY_PARTS_SEPARATOR = "&";
   static const char* QUERY_PARTS_VALUE_SEPARATOR = "=";
-  GPR_ASSERT(uri->query != NULL);
+  GPR_ASSERT(uri->query != nullptr);
   if (uri->query[0] == '\0') {
-    uri->query_parts = NULL;
-    uri->query_parts_values = NULL;
+    uri->query_parts = nullptr;
+    uri->query_parts_values = nullptr;
     uri->num_query_parts = 0;
     return;
   }
@@ -174,7 +174,7 @@ static void parse_query_parts(grpc_uri* uri) {
        * be included, even if they include the separator. */
       uri->query_parts_values[i] = query_param_parts[1];
     } else {
-      uri->query_parts_values[i] = NULL;
+      uri->query_parts_values[i] = nullptr;
     }
     for (size_t j = 2; j < num_query_param_parts; j++) {
       gpr_free(query_param_parts[j]);
@@ -289,15 +289,15 @@ grpc_uri* grpc_uri_parse(grpc_exec_ctx* exec_ctx, const char* uri_text,
 }
 
 const char* grpc_uri_get_query_arg(const grpc_uri* uri, const char* key) {
-  GPR_ASSERT(key != NULL);
-  if (key[0] == '\0') return NULL;
+  GPR_ASSERT(key != nullptr);
+  if (key[0] == '\0') return nullptr;
 
   for (size_t i = 0; i < uri->num_query_parts; ++i) {
     if (0 == strcmp(key, uri->query_parts[i])) {
       return uri->query_parts_values[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void grpc_uri_destroy(grpc_uri* uri) {

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

@@ -91,7 +91,7 @@ static void start_timer_if_needed(grpc_exec_ctx* exec_ctx,
     return;
   }
   grpc_deadline_state* deadline_state = (grpc_deadline_state*)elem->call_data;
-  grpc_closure* closure = NULL;
+  grpc_closure* closure = nullptr;
   switch (deadline_state->timer_state) {
     case GRPC_DEADLINE_STATE_PENDING:
       // Note: We do not start the timer if there is already a timer
@@ -111,7 +111,7 @@ static void start_timer_if_needed(grpc_exec_ctx* exec_ctx,
                             elem, grpc_schedule_on_exec_ctx);
       break;
   }
-  GPR_ASSERT(closure != NULL);
+  GPR_ASSERT(closure != nullptr);
   GRPC_CALL_STACK_REF(deadline_state->call_stack, "deadline_timer");
   grpc_timer_init(exec_ctx, &deadline_state->timer, deadline, closure);
 }
@@ -378,7 +378,7 @@ static bool maybe_add_deadline_filter(grpc_exec_ctx* exec_ctx,
   return grpc_deadline_checking_enabled(
              grpc_channel_stack_builder_get_channel_arguments(builder))
              ? grpc_channel_stack_builder_prepend_filter(
-                   builder, (const grpc_channel_filter*)arg, NULL, NULL)
+                   builder, (const grpc_channel_filter*)arg, nullptr, nullptr)
              : true;
 }
 

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

@@ -71,7 +71,7 @@ typedef struct channel_data {
 static grpc_error* client_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
                                                    grpc_call_element* elem,
                                                    grpc_metadata_batch* b) {
-  if (b->idx.named.status != NULL) {
+  if (b->idx.named.status != nullptr) {
     if (grpc_mdelem_eq(b->idx.named.status->md, GRPC_MDELEM_STATUS_200)) {
       grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.status);
     } else {
@@ -93,7 +93,7 @@ static grpc_error* client_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
     }
   }
 
-  if (b->idx.named.grpc_message != NULL) {
+  if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_decoded_msg = grpc_permissive_percent_decode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md));
     if (grpc_slice_is_equivalent(pct_decoded_msg,
@@ -105,7 +105,7 @@ static grpc_error* client_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
     }
   }
 
-  if (b->idx.named.content_type != NULL) {
+  if (b->idx.named.content_type != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.content_type->md,
                         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
       if (grpc_slice_buf_start_eq(GRPC_MDVALUE(b->idx.named.content_type->md),
@@ -292,7 +292,7 @@ static grpc_error* update_path_for_get(grpc_exec_ctx* exec_ctx,
 static void remove_if_present(grpc_exec_ctx* exec_ctx,
                               grpc_metadata_batch* batch,
                               grpc_metadata_batch_callouts_index idx) {
-  if (batch->idx.array[idx] != NULL) {
+  if (batch->idx.array[idx] != nullptr) {
     grpc_metadata_batch_remove(exec_ctx, batch, batch->idx.array[idx]);
   }
 }
@@ -450,7 +450,7 @@ static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
   size_t j;
   grpc_mdelem valid_schemes[] = {GRPC_MDELEM_SCHEME_HTTP,
                                  GRPC_MDELEM_SCHEME_HTTPS};
-  if (args != NULL) {
+  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) {
@@ -467,7 +467,7 @@ static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
 }
 
 static size_t max_payload_size_from_args(const grpc_channel_args* args) {
-  if (args != NULL) {
+  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) {
@@ -524,7 +524,7 @@ static grpc_slice user_agent_from_args(const grpc_channel_args* args,
     }
   }
 
-  tmp = gpr_strvec_flatten(&v, NULL);
+  tmp = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   result = grpc_slice_intern(grpc_slice_from_static_string(tmp));
   gpr_free(tmp);
@@ -538,7 +538,7 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
                                      grpc_channel_element_args* args) {
   channel_data* chand = (channel_data*)elem->channel_data;
   GPR_ASSERT(!args->is_last);
-  GPR_ASSERT(args->optional_transport != NULL);
+  GPR_ASSERT(args->optional_transport != nullptr);
   chand->static_scheme = scheme_from_args(args->channel_args);
   chand->max_payload_size_for_get =
       max_payload_size_from_args(args->channel_args);

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

@@ -37,7 +37,7 @@ static optional_filter compress_filter = {
 static bool is_building_http_like_transport(
     grpc_channel_stack_builder* builder) {
   grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
-  return t != NULL && strstr(t->vtable->name, "http");
+  return t != nullptr && strstr(t->vtable->name, "http");
 }
 
 static bool maybe_add_optional_filter(grpc_exec_ctx* exec_ctx,
@@ -51,7 +51,7 @@ static bool maybe_add_optional_filter(grpc_exec_ctx* exec_ctx,
       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, NULL, NULL)
+                      builder, filtarg->filter, nullptr, nullptr)
                 : true;
 }
 
@@ -60,7 +60,7 @@ static bool maybe_add_required_filter(grpc_exec_ctx* exec_ctx,
                                       void* arg) {
   return is_building_http_like_transport(builder)
              ? grpc_channel_stack_builder_prepend_filter(
-                   builder, (const grpc_channel_filter*)arg, NULL, NULL)
+                   builder, (const grpc_channel_filter*)arg, nullptr, nullptr)
              : true;
 }
 

src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -112,7 +112,7 @@ static grpc_error* process_send_initial_metadata(
   grpc_stream_compression_algorithm stream_compression_algorithm =
       GRPC_STREAM_COMPRESS_NONE;
   if (initial_metadata->idx.named.grpc_internal_stream_encoding_request !=
-      NULL) {
+      nullptr) {
     grpc_mdelem md =
         initial_metadata->idx.named.grpc_internal_stream_encoding_request->md;
     if (!grpc_stream_compression_algorithm_parse(
@@ -141,13 +141,13 @@ static grpc_error* process_send_initial_metadata(
         initial_metadata->idx.named.grpc_internal_stream_encoding_request);
     /* Disable message-wise compression */
     calld->compression_algorithm = GRPC_COMPRESS_NONE;
-    if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
+    if (initial_metadata->idx.named.grpc_internal_encoding_request != nullptr) {
       grpc_metadata_batch_remove(
           exec_ctx, initial_metadata,
           initial_metadata->idx.named.grpc_internal_encoding_request);
     }
   } else if (initial_metadata->idx.named.grpc_internal_encoding_request !=
-             NULL) {
+             nullptr) {
     grpc_mdelem md =
         initial_metadata->idx.named.grpc_internal_encoding_request->md;
     if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
@@ -228,7 +228,7 @@ static void send_message_batch_continue(grpc_exec_ctx* exec_ctx,
   // before we do that.
   grpc_transport_stream_op_batch* send_message_batch =
       calld->send_message_batch;
-  calld->send_message_batch = NULL;
+  calld->send_message_batch = nullptr;
   grpc_call_next_op(exec_ctx, elem, send_message_batch);
 }
 
@@ -287,11 +287,11 @@ static void fail_send_message_batch_in_call_combiner(grpc_exec_ctx* exec_ctx,
                                                      void* arg,
                                                      grpc_error* error) {
   call_data* calld = (call_data*)arg;
-  if (calld->send_message_batch != NULL) {
+  if (calld->send_message_batch != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
         exec_ctx, calld->send_message_batch, GRPC_ERROR_REF(error),
         calld->call_combiner);
-    calld->send_message_batch = NULL;
+    calld->send_message_batch = nullptr;
   }
 }
 
@@ -382,7 +382,7 @@ static void compress_start_transport_stream_op_batch(
     GRPC_ERROR_UNREF(calld->cancel_error);
     calld->cancel_error =
         GRPC_ERROR_REF(batch->payload->cancel_stream.cancel_error);
-    if (calld->send_message_batch != NULL) {
+    if (calld->send_message_batch != nullptr) {
       if (calld->send_initial_metadata_state == INITIAL_METADATA_UNSEEN) {
         GRPC_CALL_COMBINER_START(
             exec_ctx, calld->call_combiner,
@@ -423,7 +423,7 @@ static void compress_start_transport_stream_op_batch(
     // for this, since we can't send two batches down while holding the
     // call combiner, since the connected_channel filter (at the bottom of
     // the call stack) will release the call combiner for each batch it sees.
-    if (calld->send_message_batch != NULL) {
+    if (calld->send_message_batch != nullptr) {
       GRPC_CALL_COMBINER_START(
           exec_ctx, calld->call_combiner,
           &calld->start_send_message_batch_in_call_combiner, GRPC_ERROR_NONE,
@@ -432,7 +432,7 @@ static void compress_start_transport_stream_op_batch(
   }
   // Handle send_message.
   if (batch->send_message) {
-    GPR_ASSERT(calld->send_message_batch == NULL);
+    GPR_ASSERT(calld->send_message_batch == nullptr);
     calld->send_message_batch = batch;
     // If we have not yet seen send_initial_metadata, then we have to
     // wait.  We save the batch in calld and then drop the call

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

@@ -69,7 +69,7 @@ typedef struct channel_data {
 static grpc_error* server_filter_outgoing_metadata(grpc_exec_ctx* exec_ctx,
                                                    grpc_call_element* elem,
                                                    grpc_metadata_batch* b) {
-  if (b->idx.named.grpc_message != NULL) {
+  if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md),
         grpc_compatible_percent_encoding_unreserved_bytes);
@@ -100,7 +100,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
   grpc_error* error = GRPC_ERROR_NONE;
   static const char* error_name = "Failed processing incoming headers";
 
-  if (b->idx.named.method != NULL) {
+  if (b->idx.named.method != nullptr) {
     if (grpc_mdelem_eq(b->idx.named.method->md, GRPC_MDELEM_METHOD_POST)) {
       *calld->recv_initial_metadata_flags &=
           ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
@@ -132,7 +132,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
             GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":method")));
   }
 
-  if (b->idx.named.te != NULL) {
+  if (b->idx.named.te != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.te->md, GRPC_MDELEM_TE_TRAILERS)) {
       add_error(error_name, &error,
                 grpc_attach_md_to_error(
@@ -147,7 +147,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
                   GRPC_ERROR_STR_KEY, grpc_slice_from_static_string("te")));
   }
 
-  if (b->idx.named.scheme != NULL) {
+  if (b->idx.named.scheme != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTP) &&
         !grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTPS) &&
         !grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_GRPC)) {
@@ -165,7 +165,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
             GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":scheme")));
   }
 
-  if (b->idx.named.content_type != NULL) {
+  if (b->idx.named.content_type != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.content_type->md,
                         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
       if (grpc_slice_buf_start_eq(GRPC_MDVALUE(b->idx.named.content_type->md),
@@ -194,7 +194,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_type);
   }
 
-  if (b->idx.named.path == NULL) {
+  if (b->idx.named.path == nullptr) {
     add_error(error_name, &error,
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
@@ -239,7 +239,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
     }
   }
 
-  if (b->idx.named.host != NULL && b->idx.named.authority == NULL) {
+  if (b->idx.named.host != nullptr && b->idx.named.authority == nullptr) {
     grpc_linked_mdelem* el = b->idx.named.host;
     grpc_mdelem md = GRPC_MDELEM_REF(el->md);
     grpc_metadata_batch_remove(exec_ctx, b, el);
@@ -252,7 +252,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
     GRPC_MDELEM_UNREF(exec_ctx, md);
   }
 
-  if (b->idx.named.authority == NULL) {
+  if (b->idx.named.authority == nullptr) {
     add_error(
         error_name, &error,
         grpc_error_set_str(
@@ -281,16 +281,16 @@ static void hs_on_complete(grpc_exec_ctx* exec_ctx, void* user_data,
   grpc_call_element* elem = (grpc_call_element*)user_data;
   call_data* calld = (call_data*)elem->call_data;
   /* Call recv_message_ready if we got the payload via the path field */
-  if (calld->seen_path_with_query && calld->recv_message_ready != NULL) {
+  if (calld->seen_path_with_query && calld->recv_message_ready != nullptr) {
     *calld->pp_recv_message = calld->payload_bin_delivered
-                                  ? NULL
+                                  ? nullptr
                                   : (grpc_byte_stream*)&calld->read_stream;
     // Re-enter call combiner for recv_message_ready, since the surface
     // code will release the call combiner for each callback it receives.
     GRPC_CALL_COMBINER_START(exec_ctx, calld->call_combiner,
                              calld->recv_message_ready, GRPC_ERROR_REF(err),
                              "resuming recv_message_ready from on_complete");
-    calld->recv_message_ready = NULL;
+    calld->recv_message_ready = nullptr;
     calld->payload_bin_delivered = true;
   }
   GRPC_CLOSURE_RUN(exec_ctx, calld->on_complete, GRPC_ERROR_REF(err));
@@ -341,7 +341,7 @@ static grpc_error* hs_mutate_op(grpc_exec_ctx* exec_ctx,
 
   if (op->recv_initial_metadata) {
     /* substitute our callback for the higher callback */
-    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != NULL);
+    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != nullptr);
     calld->recv_initial_metadata =
         op->payload->recv_initial_metadata.recv_initial_metadata;
     calld->recv_initial_metadata_flags =

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

@@ -60,7 +60,7 @@ static void on_initial_md_ready(grpc_exec_ctx* exec_ctx, void* user_data,
   call_data* calld = (call_data*)elem->call_data;
 
   if (err == GRPC_ERROR_NONE) {
-    if (calld->recv_initial_metadata->idx.named.path != NULL) {
+    if (calld->recv_initial_metadata->idx.named.path != nullptr) {
       calld->service_method = grpc_slice_ref_internal(
           GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.path->md));
       calld->have_service_method = true;
@@ -68,7 +68,7 @@ static void on_initial_md_ready(grpc_exec_ctx* exec_ctx, void* user_data,
       err = grpc_error_add_child(
           err, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing :path header"));
     }
-    if (calld->recv_initial_metadata->idx.named.lb_token != NULL) {
+    if (calld->recv_initial_metadata->idx.named.lb_token != nullptr) {
       calld->initial_md_string = grpc_slice_ref_internal(
           GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.lb_token->md));
       calld->have_initial_md_string = true;

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

@@ -48,8 +48,8 @@ static bool maybe_add_server_load_reporting_filter(
       !grpc_channel_stack_builder_iterator_is_end(it);
   grpc_channel_stack_builder_iterator_destroy(it);
   if (is_load_reporting_enabled(args) && !already_has_load_reporting_filter) {
-    return grpc_channel_stack_builder_prepend_filter(builder, filter, NULL,
-                                                     NULL);
+    return grpc_channel_stack_builder_prepend_filter(builder, filter, nullptr,
+                                                     nullptr);
   }
   return true;
 }

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

@@ -126,7 +126,7 @@ static void start_max_age_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
                   grpc_exec_ctx_now(exec_ctx) + chand->max_connection_age,
                   &chand->close_max_age_channel);
   gpr_mu_unlock(&chand->max_age_timer_mu);
-  grpc_transport_op* op = grpc_make_transport_op(NULL);
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->on_connectivity_state_change = &chand->channel_connectivity_changed,
   op->connectivity_state = &chand->connectivity_state;
   grpc_channel_next_op(exec_ctx,
@@ -159,7 +159,7 @@ static void close_max_idle_channel(grpc_exec_ctx* exec_ctx, void* arg,
   if (error == GRPC_ERROR_NONE) {
     /* Prevent the max idle timer from being set again */
     gpr_atm_no_barrier_fetch_add(&chand->call_count, 1);
-    grpc_transport_op* op = grpc_make_transport_op(NULL);
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->goaway_error =
         grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING("max_idle"),
                            GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
@@ -204,7 +204,7 @@ static void force_close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
   chand->max_age_grace_timer_pending = false;
   gpr_mu_unlock(&chand->max_age_timer_mu);
   if (error == GRPC_ERROR_NONE) {
-    grpc_transport_op* op = grpc_make_transport_op(NULL);
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel reaches max age");
     grpc_channel_element* elem =
@@ -221,7 +221,7 @@ static void channel_connectivity_changed(grpc_exec_ctx* exec_ctx, void* arg,
                                          grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
-    grpc_transport_op* op = grpc_make_transport_op(NULL);
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->on_connectivity_state_change = &chand->channel_connectivity_changed,
     op->connectivity_state = &chand->connectivity_state;
     grpc_channel_next_op(
@@ -398,7 +398,7 @@ static bool maybe_add_max_age_filter(grpc_exec_ctx* exec_ctx,
           MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX;
   if (enable) {
     return grpc_channel_stack_builder_prepend_filter(
-        builder, &grpc_max_age_filter, NULL, NULL);
+        builder, &grpc_max_age_filter, nullptr, nullptr);
   } else {
     return true;
   }
@@ -407,7 +407,7 @@ static bool maybe_add_max_age_filter(grpc_exec_ctx* exec_ctx,
 extern "C" void grpc_max_age_filter_init(void) {
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_max_age_filter, NULL);
+                                   maybe_add_max_age_filter, nullptr);
 }
 
 extern "C" void grpc_max_age_filter_shutdown(void) {}

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

@@ -60,22 +60,22 @@ static void* refcounted_message_size_limits_create_from_json(
     const grpc_json* json) {
   int max_request_message_bytes = -1;
   int max_response_message_bytes = -1;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) continue;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) continue;
     if (strcmp(field->key, "maxRequestMessageBytes") == 0) {
-      if (max_request_message_bytes >= 0) return NULL;  // Duplicate.
+      if (max_request_message_bytes >= 0) return nullptr;  // Duplicate.
       if (field->type != GRPC_JSON_STRING && field->type != GRPC_JSON_NUMBER) {
-        return NULL;
+        return nullptr;
       }
       max_request_message_bytes = gpr_parse_nonnegative_int(field->value);
-      if (max_request_message_bytes == -1) return NULL;
+      if (max_request_message_bytes == -1) return nullptr;
     } else if (strcmp(field->key, "maxResponseMessageBytes") == 0) {
-      if (max_response_message_bytes >= 0) return NULL;  // Duplicate.
+      if (max_response_message_bytes >= 0) return nullptr;  // Duplicate.
       if (field->type != GRPC_JSON_STRING && field->type != GRPC_JSON_NUMBER) {
-        return NULL;
+        return nullptr;
       }
       max_response_message_bytes = gpr_parse_nonnegative_int(field->value);
-      if (max_response_message_bytes == -1) return NULL;
+      if (max_response_message_bytes == -1) return nullptr;
     }
   }
   refcounted_message_size_limits* value =
@@ -112,7 +112,7 @@ static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,
                                grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)user_data;
   call_data* calld = (call_data*)elem->call_data;
-  if (*calld->recv_message != NULL && calld->limits.max_recv_size >= 0 &&
+  if (*calld->recv_message != nullptr && calld->limits.max_recv_size >= 0 &&
       (*calld->recv_message)->length > (size_t)calld->limits.max_recv_size) {
     char* message_string;
     gpr_asprintf(&message_string,
@@ -175,7 +175,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
   channel_data* chand = (channel_data*)elem->channel_data;
   call_data* calld = (call_data*)elem->call_data;
   calld->call_combiner = args->call_combiner;
-  calld->next_recv_message_ready = NULL;
+  calld->next_recv_message_ready = nullptr;
   GRPC_CLOSURE_INIT(&calld->recv_message_ready, recv_message_ready, elem,
                     grpc_schedule_on_exec_ctx);
   // Get max sizes from channel data, then merge in per-method config values.
@@ -183,11 +183,11 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
   // apply the max request size to the send limit and the max response
   // size to the receive limit.
   calld->limits = chand->limits;
-  if (chand->method_limit_table != NULL) {
+  if (chand->method_limit_table != nullptr) {
     refcounted_message_size_limits* limits =
         (refcounted_message_size_limits*)grpc_method_config_table_get(
             exec_ctx, chand->method_limit_table, args->path);
-    if (limits != NULL) {
+    if (limits != nullptr) {
       if (limits->limits.max_send_size >= 0 &&
           (limits->limits.max_send_size < calld->limits.max_send_size ||
            calld->limits.max_send_size < 0)) {
@@ -250,11 +250,11 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
   // Get method config table from channel args.
   const grpc_arg* channel_arg =
       grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG);
-  if (channel_arg != NULL) {
+  if (channel_arg != nullptr) {
     GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING);
     grpc_service_config* service_config =
         grpc_service_config_create(channel_arg->value.string);
-    if (service_config != NULL) {
+    if (service_config != nullptr) {
       chand->method_limit_table =
           grpc_service_config_create_method_config_table(
               exec_ctx, service_config,
@@ -299,12 +299,12 @@ static bool maybe_add_message_size_filter(grpc_exec_ctx* exec_ctx,
   }
   const grpc_arg* a =
       grpc_channel_args_find(channel_args, GRPC_ARG_SERVICE_CONFIG);
-  if (a != NULL) {
+  if (a != nullptr) {
     enable = true;
   }
   if (enable) {
     return grpc_channel_stack_builder_prepend_filter(
-        builder, &grpc_message_size_filter, NULL, NULL);
+        builder, &grpc_message_size_filter, nullptr, nullptr);
   } else {
     return true;
   }
@@ -313,13 +313,13 @@ static bool maybe_add_message_size_filter(grpc_exec_ctx* exec_ctx,
 extern "C" void grpc_message_size_filter_init(void) {
   grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_message_size_filter, NULL);
+                                   maybe_add_message_size_filter, nullptr);
   grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_message_size_filter, NULL);
+                                   maybe_add_message_size_filter, nullptr);
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_message_size_filter, NULL);
+                                   maybe_add_message_size_filter, nullptr);
 }
 
 extern "C" void grpc_message_size_filter_shutdown(void) {}

src/core/ext/filters/workarounds/workaround_cronet_compression_filter.cc

@@ -42,7 +42,7 @@ typedef struct call_data {
 // Find the user agent metadata element in the batch
 static bool get_user_agent_mdelem(const grpc_metadata_batch* batch,
                                   grpc_mdelem* md) {
-  if (batch->idx.named.user_agent != NULL) {
+  if (batch->idx.named.user_agent != nullptr) {
     *md = batch->idx.named.user_agent->md;
     return true;
   }
@@ -104,7 +104,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
                                   grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   call_data* calld = (call_data*)elem->call_data;
-  calld->next_recv_initial_metadata_ready = NULL;
+  calld->next_recv_initial_metadata_ready = nullptr;
   calld->workaround_active = false;
   GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
                     recv_initial_metadata_ready, elem,
@@ -142,7 +142,7 @@ static bool parse_user_agent(grpc_mdelem md) {
   long major_version, minor_version;
 
   char* head = strtok(user_agent_str, " ");
-  while (head != NULL) {
+  while (head != nullptr) {
     if (!grpc_objc_specifier_seen &&
         0 == strncmp(head, grpc_objc_specifier, grpc_objc_specifier_len)) {
       major_version_str = head + grpc_objc_specifier_len;
@@ -153,11 +153,11 @@ static bool parse_user_agent(grpc_mdelem md) {
       break;
     }
 
-    head = strtok(NULL, " ");
+    head = strtok(nullptr, " ");
   }
   if (grpc_objc_specifier_seen) {
     major_version_str = strtok(major_version_str, ".");
-    minor_version_str = strtok(NULL, ".");
+    minor_version_str = strtok(nullptr, ".");
     major_version = atol(major_version_str);
     minor_version = atol(minor_version_str);
   }
@@ -186,20 +186,20 @@ static bool register_workaround_cronet_compression(
       grpc_channel_stack_builder_get_channel_arguments(builder);
   const grpc_arg* a = grpc_channel_args_find(
       channel_args, GRPC_ARG_WORKAROUND_CRONET_COMPRESSION);
-  if (a == NULL) {
+  if (a == nullptr) {
     return true;
   }
   if (grpc_channel_arg_get_bool(a, false) == false) {
     return true;
   }
   return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_workaround_cronet_compression_filter, NULL, NULL);
+      builder, &grpc_workaround_cronet_compression_filter, nullptr, nullptr);
 }
 
 extern "C" void grpc_workaround_cronet_compression_filter_init(void) {
   grpc_channel_init_register_stage(
       GRPC_SERVER_CHANNEL, GRPC_WORKAROUND_PRIORITY_HIGH,
-      register_workaround_cronet_compression, NULL);
+      register_workaround_cronet_compression, nullptr);
   grpc_register_workaround(GRPC_WORKAROUND_ID_CRONET_COMPRESSION,
                            parse_user_agent);
 }

src/core/ext/filters/workarounds/workaround_utils.cc

@@ -30,7 +30,7 @@ grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md) {
       (grpc_workaround_user_agent_md*)grpc_mdelem_get_user_data(
           md, destroy_user_agent_md);
 
-  if (NULL != user_agent_md) {
+  if (nullptr != user_agent_md) {
     return user_agent_md;
   }
   user_agent_md = (grpc_workaround_user_agent_md*)gpr_malloc(

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

@@ -68,7 +68,7 @@ static void chttp2_connector_unref(grpc_exec_ctx* exec_ctx,
     gpr_mu_destroy(&c->mu);
     // If handshaking is not yet in progress, destroy the endpoint.
     // Otherwise, the handshaker will do this for us.
-    if (c->endpoint != NULL) grpc_endpoint_destroy(exec_ctx, c->endpoint);
+    if (c->endpoint != nullptr) grpc_endpoint_destroy(exec_ctx, c->endpoint);
     gpr_free(c);
   }
 }
@@ -78,13 +78,13 @@ static void chttp2_connector_shutdown(grpc_exec_ctx* exec_ctx,
   chttp2_connector* c = (chttp2_connector*)con;
   gpr_mu_lock(&c->mu);
   c->shutdown = true;
-  if (c->handshake_mgr != NULL) {
+  if (c->handshake_mgr != nullptr) {
     grpc_handshake_manager_shutdown(exec_ctx, c->handshake_mgr,
                                     GRPC_ERROR_REF(why));
   }
   // If handshaking is not yet in progress, shutdown the endpoint.
   // Otherwise, the handshaker will do this for us.
-  if (!c->connecting && c->endpoint != NULL) {
+  if (!c->connecting && c->endpoint != nullptr) {
     grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(why));
   }
   gpr_mu_unlock(&c->mu);
@@ -149,10 +149,10 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
     c->result->channel_args = args->args;
   }
   grpc_closure* notify = c->notify;
-  c->notify = NULL;
+  c->notify = nullptr;
   GRPC_CLOSURE_SCHED(exec_ctx, notify, error);
   grpc_handshake_manager_destroy(exec_ctx, c->handshake_mgr);
-  c->handshake_mgr = NULL;
+  c->handshake_mgr = nullptr;
   gpr_mu_unlock(&c->mu);
   chttp2_connector_unref(exec_ctx, (grpc_connector*)c);
 }
@@ -166,8 +166,8 @@ static void start_handshake_locked(grpc_exec_ctx* exec_ctx,
                                    c->args.interested_parties);
   grpc_handshake_manager_do_handshake(
       exec_ctx, c->handshake_mgr, c->endpoint, c->args.channel_args,
-      c->args.deadline, NULL /* acceptor */, on_handshake_done, c);
-  c->endpoint = NULL;  // Endpoint handed off to handshake manager.
+      c->args.deadline, nullptr /* acceptor */, on_handshake_done, c);
+  c->endpoint = nullptr;  // Endpoint handed off to handshake manager.
 }
 
 static void connected(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
@@ -183,15 +183,15 @@ static void connected(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
     }
     memset(c->result, 0, sizeof(*c->result));
     grpc_closure* notify = c->notify;
-    c->notify = NULL;
+    c->notify = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, notify, error);
-    if (c->endpoint != NULL) {
+    if (c->endpoint != nullptr) {
       grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(error));
     }
     gpr_mu_unlock(&c->mu);
     chttp2_connector_unref(exec_ctx, (grpc_connector*)arg);
   } else {
-    GPR_ASSERT(c->endpoint != NULL);
+    GPR_ASSERT(c->endpoint != nullptr);
     start_handshake_locked(exec_ctx, c);
     gpr_mu_unlock(&c->mu);
   }
@@ -206,11 +206,11 @@ static void chttp2_connector_connect(grpc_exec_ctx* exec_ctx,
   grpc_resolved_address addr;
   grpc_get_subchannel_address_arg(exec_ctx, args->channel_args, &addr);
   gpr_mu_lock(&c->mu);
-  GPR_ASSERT(c->notify == NULL);
+  GPR_ASSERT(c->notify == nullptr);
   c->notify = notify;
   c->args = *args;
   c->result = result;
-  GPR_ASSERT(c->endpoint == NULL);
+  GPR_ASSERT(c->endpoint == nullptr);
   chttp2_connector_ref(con);  // Ref taken for callback.
   GRPC_CLOSURE_INIT(&c->connected, connected, c, grpc_schedule_on_exec_ctx);
   GPR_ASSERT(!c->connecting);

src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -49,9 +49,9 @@ static grpc_channel* client_channel_factory_create_channel(
     grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
     const char* target, grpc_client_channel_type type,
     const grpc_channel_args* args) {
-  if (target == NULL) {
+  if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
-    return NULL;
+    return nullptr;
   }
   // Add channel arg containing the server URI.
   grpc_arg arg = grpc_channel_arg_string_create(
@@ -62,7 +62,7 @@ static grpc_channel* client_channel_factory_create_channel(
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   gpr_free(arg.value.string);
   grpc_channel* channel = grpc_channel_create(exec_ctx, target, new_args,
-                                              GRPC_CLIENT_CHANNEL, NULL);
+                                              GRPC_CLIENT_CHANNEL, nullptr);
   grpc_channel_args_destroy(exec_ctx, new_args);
   return channel;
 }
@@ -86,7 +86,7 @@ grpc_channel* grpc_insecure_channel_create(const char* target,
   GRPC_API_TRACE(
       "grpc_insecure_channel_create(target=%s, args=%p, reserved=%p)", 3,
       (target, args, reserved));
-  GPR_ASSERT(reserved == NULL);
+  GPR_ASSERT(reserved == nullptr);
   // Add channel arg containing the client channel factory.
   grpc_arg arg =
       grpc_client_channel_factory_create_channel_arg(&client_channel_factory);
@@ -98,8 +98,8 @@ grpc_channel* grpc_insecure_channel_create(const char* target,
   // Clean up.
   grpc_channel_args_destroy(&exec_ctx, new_args);
   grpc_exec_ctx_finish(&exec_ctx);
-  return channel != NULL ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create client channel");
+  return channel != nullptr ? channel
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create client channel");
 }

src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc

@@ -62,10 +62,10 @@ grpc_channel* grpc_insecure_channel_create_from_fd(
 
   grpc_exec_ctx_finish(&exec_ctx);
 
-  return channel != NULL ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create client channel");
+  return channel != nullptr ? channel
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create client channel");
 }
 
 #else  // !GPR_SUPPORT_CHANNELS_FROM_FD

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

@@ -47,51 +47,51 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     grpc_exec_ctx* exec_ctx, const grpc_subchannel_args* args) {
   grpc_channel_credentials* channel_credentials =
       grpc_channel_credentials_find_in_args(args->args);
-  if (channel_credentials == NULL) {
+  if (channel_credentials == nullptr) {
     gpr_log(GPR_ERROR,
             "Can't create subchannel: channel credentials missing for secure "
             "channel.");
-    return NULL;
+    return nullptr;
   }
   // Make sure security connector does not already exist in args.
-  if (grpc_security_connector_find_in_args(args->args) != NULL) {
+  if (grpc_security_connector_find_in_args(args->args) != nullptr) {
     gpr_log(GPR_ERROR,
             "Can't create subchannel: security connector already present in "
             "channel args.");
-    return NULL;
+    return nullptr;
   }
   // To which address are we connecting? By default, use the server URI.
   const grpc_arg* server_uri_arg =
       grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI);
-  GPR_ASSERT(server_uri_arg != NULL);
+  GPR_ASSERT(server_uri_arg != nullptr);
   GPR_ASSERT(server_uri_arg->type == GRPC_ARG_STRING);
   const char* server_uri_str = server_uri_arg->value.string;
-  GPR_ASSERT(server_uri_str != NULL);
+  GPR_ASSERT(server_uri_str != nullptr);
   grpc_uri* server_uri =
       grpc_uri_parse(exec_ctx, server_uri_str, true /* supress errors */);
-  GPR_ASSERT(server_uri != NULL);
+  GPR_ASSERT(server_uri != nullptr);
   const char* server_uri_path;
   server_uri_path =
       server_uri->path[0] == '/' ? server_uri->path + 1 : server_uri->path;
   const grpc_slice_hash_table* targets_info =
       grpc_lb_targets_info_find_in_args(args->args);
-  char* target_name_to_check = NULL;
-  if (targets_info != NULL) {  // LB channel
+  char* target_name_to_check = nullptr;
+  if (targets_info != nullptr) {  // LB channel
     // Find the balancer name for the target.
     const char* target_uri_str =
         grpc_get_subchannel_address_uri_arg(args->args);
     grpc_uri* target_uri =
         grpc_uri_parse(exec_ctx, target_uri_str, false /* suppress errors */);
-    GPR_ASSERT(target_uri != NULL);
+    GPR_ASSERT(target_uri != nullptr);
     if (target_uri->path[0] != '\0') {  // "path" may be empty
       const grpc_slice key = grpc_slice_from_static_string(
           target_uri->path[0] == '/' ? target_uri->path + 1 : target_uri->path);
       const char* value =
           (const char*)grpc_slice_hash_table_get(targets_info, key);
-      if (value != NULL) target_name_to_check = gpr_strdup(value);
+      if (value != nullptr) target_name_to_check = gpr_strdup(value);
       grpc_slice_unref_internal(exec_ctx, key);
     }
-    if (target_name_to_check == NULL) {
+    if (target_name_to_check == nullptr) {
       // If the target name to check hasn't already been set, fall back to using
       // SERVER_URI
       target_name_to_check = gpr_strdup(server_uri_path);
@@ -101,10 +101,10 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     target_name_to_check = gpr_strdup(server_uri_path);
   }
   grpc_uri_destroy(server_uri);
-  GPR_ASSERT(target_name_to_check != NULL);
-  grpc_channel_security_connector* subchannel_security_connector = NULL;
+  GPR_ASSERT(target_name_to_check != nullptr);
+  grpc_channel_security_connector* subchannel_security_connector = nullptr;
   // Create the security connector using the credentials and target name.
-  grpc_channel_args* new_args_from_connector = NULL;
+  grpc_channel_args* new_args_from_connector = nullptr;
   const grpc_security_status security_status =
       grpc_channel_credentials_create_security_connector(
           exec_ctx, channel_credentials, target_name_to_check, args->args,
@@ -114,18 +114,18 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
             "Failed to create secure subchannel for secure name '%s'",
             target_name_to_check);
     gpr_free(target_name_to_check);
-    return NULL;
+    return nullptr;
   }
   gpr_free(target_name_to_check);
   grpc_arg new_security_connector_arg =
       grpc_security_connector_to_arg(&subchannel_security_connector->base);
 
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
-      new_args_from_connector != NULL ? new_args_from_connector : args->args,
+      new_args_from_connector != nullptr ? new_args_from_connector : args->args,
       &new_security_connector_arg, 1);
   GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &subchannel_security_connector->base,
                                 "lb_channel_create");
-  if (new_args_from_connector != NULL) {
+  if (new_args_from_connector != nullptr) {
     grpc_channel_args_destroy(exec_ctx, new_args_from_connector);
   }
   grpc_subchannel_args* final_sc_args =
@@ -140,11 +140,11 @@ static grpc_subchannel* client_channel_factory_create_subchannel(
     const grpc_subchannel_args* args) {
   grpc_subchannel_args* subchannel_args =
       get_secure_naming_subchannel_args(exec_ctx, args);
-  if (subchannel_args == NULL) {
+  if (subchannel_args == nullptr) {
     gpr_log(
         GPR_ERROR,
         "Failed to create subchannel arguments during subchannel creation.");
-    return NULL;
+    return nullptr;
   }
   grpc_connector* connector = grpc_chttp2_connector_create();
   grpc_subchannel* s =
@@ -160,9 +160,9 @@ static grpc_channel* client_channel_factory_create_channel(
     grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
     const char* target, grpc_client_channel_type type,
     const grpc_channel_args* args) {
-  if (target == NULL) {
+  if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
-    return NULL;
+    return nullptr;
   }
   // Add channel arg containing the server URI.
   grpc_arg arg = grpc_channel_arg_string_create(
@@ -173,7 +173,7 @@ static grpc_channel* client_channel_factory_create_channel(
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   gpr_free(arg.value.string);
   grpc_channel* channel = grpc_channel_create(exec_ctx, target, new_args,
-                                              GRPC_CLIENT_CHANNEL, NULL);
+                                              GRPC_CLIENT_CHANNEL, nullptr);
   grpc_channel_args_destroy(exec_ctx, new_args);
   return channel;
 }
@@ -199,9 +199,9 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
       "grpc_secure_channel_create(creds=%p, target=%s, args=%p, "
       "reserved=%p)",
       4, ((void*)creds, target, (void*)args, (void*)reserved));
-  GPR_ASSERT(reserved == NULL);
-  grpc_channel* channel = NULL;
-  if (creds != NULL) {
+  GPR_ASSERT(reserved == nullptr);
+  grpc_channel* channel = nullptr;
+  if (creds != nullptr) {
     // Add channel args containing the client channel factory and channel
     // credentials.
     grpc_arg args_to_add[] = {
@@ -217,8 +217,8 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
     grpc_channel_args_destroy(&exec_ctx, new_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
-  return channel != NULL ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create secure client channel");
+  return channel != nullptr ? channel
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create secure client channel");
 }

src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -108,7 +108,7 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
   if (error != GRPC_ERROR_NONE || connection_state->svr_state->shutdown) {
     const char* error_str = grpc_error_string(error);
     gpr_log(GPR_DEBUG, "Handshaking failed: %s", error_str);
-    if (error == GRPC_ERROR_NONE && args->endpoint != NULL) {
+    if (error == GRPC_ERROR_NONE && args->endpoint != nullptr) {
       // We were shut down after handshaking completed successfully, so
       // destroy the endpoint here.
       // TODO(ctiller): It is currently necessary to shutdown endpoints
@@ -125,7 +125,7 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
     // If the handshaking succeeded but there is no endpoint, then the
     // handshaker may have handed off the connection to some external
     // code, so we can just clean up here without creating a transport.
-    if (args->endpoint != NULL) {
+    if (args->endpoint != nullptr) {
       grpc_transport* transport = grpc_create_chttp2_transport(
           exec_ctx, args->args, args->endpoint, false);
       grpc_server_setup_transport(
@@ -225,7 +225,7 @@ static void tcp_server_shutdown_complete(grpc_exec_ctx* exec_ctx, void* arg,
   // Flush queued work before destroying handshaker factory, since that
   // may do a synchronous unref.
   grpc_exec_ctx_flush(exec_ctx);
-  if (destroy_done != NULL) {
+  if (destroy_done != nullptr) {
     destroy_done->cb(exec_ctx, destroy_done->cb_arg, GRPC_ERROR_REF(error));
     grpc_exec_ctx_flush(exec_ctx);
   }
@@ -253,14 +253,14 @@ grpc_error* grpc_chttp2_server_add_port(grpc_exec_ctx* exec_ctx,
                                         grpc_server* server, const char* addr,
                                         grpc_channel_args* args,
                                         int* port_num) {
-  grpc_resolved_addresses* resolved = NULL;
-  grpc_tcp_server* tcp_server = NULL;
+  grpc_resolved_addresses* resolved = nullptr;
+  grpc_tcp_server* tcp_server = nullptr;
   size_t i;
   size_t count = 0;
   int port_temp;
   grpc_error* err = GRPC_ERROR_NONE;
-  server_state* state = NULL;
-  grpc_error** errors = NULL;
+  server_state* state = nullptr;
+  grpc_error** errors = nullptr;
   size_t naddrs = 0;
 
   *port_num = -1;
@@ -343,7 +343,7 @@ error:
   *port_num = 0;
 
 done:
-  if (errors != NULL) {
+  if (errors != nullptr) {
     for (i = 0; i < naddrs; i++) {
       GRPC_ERROR_UNREF(errors[i]);
     }

src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -36,7 +36,7 @@
 
 void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
                                               void* reserved, int fd) {
-  GPR_ASSERT(reserved == NULL);
+  GPR_ASSERT(reserved == nullptr);
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   char* name;
@@ -60,7 +60,8 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
     grpc_endpoint_add_to_pollset(&exec_ctx, server_endpoint, pollsets[i]);
   }
 
-  grpc_server_setup_transport(&exec_ctx, server, transport, NULL, server_args);
+  grpc_server_setup_transport(&exec_ctx, server, transport, nullptr,
+                              server_args);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }

src/core/ext/transport/chttp2/server/secure/server_secure_chttp2.cc

@@ -38,16 +38,16 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
                                       grpc_server_credentials* creds) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_error* err = GRPC_ERROR_NONE;
-  grpc_server_security_connector* sc = NULL;
+  grpc_server_security_connector* sc = nullptr;
   int port_num = 0;
   grpc_security_status status;
-  grpc_channel_args* args = NULL;
+  grpc_channel_args* args = nullptr;
   GRPC_API_TRACE(
       "grpc_server_add_secure_http2_port("
       "server=%p, addr=%s, creds=%p)",
       3, (server, addr, creds));
   // Create security context.
-  if (creds == NULL) {
+  if (creds == nullptr) {
     err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "No credentials specified for secure server port (creds==NULL)");
     goto done;
@@ -74,7 +74,7 @@ int grpc_server_add_secure_http2_port(grpc_server* server, const char* addr,
   // Add server port.
   err = grpc_chttp2_server_add_port(&exec_ctx, server, addr, args, &port_num);
 done:
-  if (sc != NULL) {
+  if (sc != nullptr) {
     GRPC_SECURITY_CONNECTOR_UNREF(&exec_ctx, &sc->base, "server");
   }
   grpc_exec_ctx_finish(&exec_ctx);

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

@@ -201,10 +201,12 @@ static void destruct_transport(grpc_exec_ctx* exec_ctx,
   grpc_chttp2_goaway_parser_destroy(&t->goaway_parser);
 
   for (i = 0; i < STREAM_LIST_COUNT; i++) {
-    GPR_ASSERT(t->lists[i].head == NULL);
-    GPR_ASSERT(t->lists[i].tail == NULL);
+    GPR_ASSERT(t->lists[i].head == nullptr);
+    GPR_ASSERT(t->lists[i].tail == nullptr);
   }
 
+  GRPC_ERROR_UNREF(t->goaway_error);
+
   GPR_ASSERT(grpc_chttp2_stream_map_size(&t->stream_map) == 0);
 
   grpc_chttp2_stream_map_destroy(&t->stream_map);
@@ -320,6 +322,7 @@ static void init_transport(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
                     keepalive_watchdog_fired_locked, t,
                     grpc_combiner_scheduler(t->combiner));
 
+  t->goaway_error = GRPC_ERROR_NONE;
   grpc_chttp2_goaway_parser_init(&t->goaway_parser);
   grpc_chttp2_hpack_parser_init(exec_ctx, &t->hpack_parser);
 
@@ -572,7 +575,7 @@ static void init_transport(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
     schedule_bdp_ping_locked(exec_ctx, t);
 
     grpc_chttp2_act_on_flowctl_action(
-        exec_ctx, t->flow_control->PeriodicUpdate(exec_ctx), t, NULL);
+        exec_ctx, t->flow_control->PeriodicUpdate(exec_ctx), t, nullptr);
   }
 
   grpc_chttp2_initiate_write(exec_ctx, t,
@@ -611,7 +614,7 @@ static void close_transport_locked(grpc_exec_ctx* exec_ctx,
                                  GRPC_STATUS_UNAVAILABLE);
     }
     if (t->write_state != GRPC_CHTTP2_WRITE_STATE_IDLE) {
-      if (t->close_transport_on_writes_finished == NULL) {
+      if (t->close_transport_on_writes_finished == nullptr) {
         t->close_transport_on_writes_finished =
             GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                 "Delayed close due to in-progress write");
@@ -726,7 +729,7 @@ static void destroy_stream_locked(grpc_exec_ctx* exec_ctx, void* sp,
 
   GPR_ASSERT((s->write_closed && s->read_closed) || s->id == 0);
   if (s->id != 0) {
-    GPR_ASSERT(grpc_chttp2_stream_map_find(&t->stream_map, s->id) == NULL);
+    GPR_ASSERT(grpc_chttp2_stream_map_find(&t->stream_map, s->id) == nullptr);
   }
 
   grpc_slice_buffer_destroy_internal(exec_ctx,
@@ -746,12 +749,12 @@ static void destroy_stream_locked(grpc_exec_ctx* exec_ctx, void* sp,
     }
   }
 
-  GPR_ASSERT(s->send_initial_metadata_finished == NULL);
-  GPR_ASSERT(s->fetching_send_message == NULL);
-  GPR_ASSERT(s->send_trailing_metadata_finished == NULL);
-  GPR_ASSERT(s->recv_initial_metadata_ready == NULL);
-  GPR_ASSERT(s->recv_message_ready == NULL);
-  GPR_ASSERT(s->recv_trailing_metadata_finished == NULL);
+  GPR_ASSERT(s->send_initial_metadata_finished == nullptr);
+  GPR_ASSERT(s->fetching_send_message == nullptr);
+  GPR_ASSERT(s->send_trailing_metadata_finished == nullptr);
+  GPR_ASSERT(s->recv_initial_metadata_ready == nullptr);
+  GPR_ASSERT(s->recv_message_ready == nullptr);
+  GPR_ASSERT(s->recv_trailing_metadata_finished == nullptr);
   grpc_chttp2_data_parser_destroy(exec_ctx, &s->data_parser);
   grpc_chttp2_incoming_metadata_buffer_destroy(exec_ctx,
                                                &s->metadata_buffer[0]);
@@ -778,13 +781,13 @@ static void destroy_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
   grpc_chttp2_stream* s = (grpc_chttp2_stream*)gs;
 
-  if (s->stream_compression_ctx != NULL) {
+  if (s->stream_compression_ctx != nullptr) {
     grpc_stream_compression_context_destroy(s->stream_compression_ctx);
-    s->stream_compression_ctx = NULL;
+    s->stream_compression_ctx = nullptr;
   }
-  if (s->stream_decompression_ctx != NULL) {
+  if (s->stream_decompression_ctx != nullptr) {
     grpc_stream_compression_context_destroy(s->stream_decompression_ctx);
-    s->stream_decompression_ctx = NULL;
+    s->stream_decompression_ctx = nullptr;
   }
 
   s->destroy_stream_arg = then_schedule_closure;
@@ -804,16 +807,16 @@ grpc_chttp2_stream* grpc_chttp2_parsing_lookup_stream(grpc_chttp2_transport* t,
 grpc_chttp2_stream* grpc_chttp2_parsing_accept_stream(grpc_exec_ctx* exec_ctx,
                                                       grpc_chttp2_transport* t,
                                                       uint32_t id) {
-  if (t->channel_callback.accept_stream == NULL) {
-    return NULL;
+  if (t->channel_callback.accept_stream == nullptr) {
+    return nullptr;
   }
   grpc_chttp2_stream* accepting;
-  GPR_ASSERT(t->accepting_stream == NULL);
+  GPR_ASSERT(t->accepting_stream == nullptr);
   t->accepting_stream = &accepting;
   t->channel_callback.accept_stream(exec_ctx,
                                     t->channel_callback.accept_stream_user_data,
                                     &t->base, (void*)(uintptr_t)id);
-  t->accepting_stream = NULL;
+  t->accepting_stream = nullptr;
   return accepting;
 }
 
@@ -842,9 +845,9 @@ static void set_write_state(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
   t->write_state = st;
   if (st == GRPC_CHTTP2_WRITE_STATE_IDLE) {
     GRPC_CLOSURE_LIST_SCHED(exec_ctx, &t->run_after_write);
-    if (t->close_transport_on_writes_finished != NULL) {
+    if (t->close_transport_on_writes_finished != nullptr) {
       grpc_error* err = t->close_transport_on_writes_finished;
-      t->close_transport_on_writes_finished = NULL;
+      t->close_transport_on_writes_finished = nullptr;
       close_transport_locked(exec_ctx, t, err);
     }
   }
@@ -984,7 +987,7 @@ static grpc_closure_scheduler* write_scheduler(grpc_chttp2_transport* t,
     case GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY:
       return grpc_schedule_on_exec_ctx;
   }
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
 #define WRITE_STATE_TUPLE_TO_INT(p, i) (2 * (int)(p) + (int)(i))
@@ -1123,7 +1126,16 @@ void grpc_chttp2_add_incoming_goaway(grpc_exec_ctx* exec_ctx,
                                      grpc_slice goaway_text) {
   // GRPC_CHTTP2_IF_TRACING(
   //     gpr_log(GPR_DEBUG, "got goaway [%d]: %s", goaway_error, msg));
-  t->seen_goaway = 1;
+
+  // Discard the error from a previous goaway frame (if any)
+  if (t->goaway_error != GRPC_ERROR_NONE) {
+    GRPC_ERROR_UNREF(t->goaway_error);
+  }
+  t->goaway_error = grpc_error_set_str(
+      grpc_error_set_int(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("GOAWAY received"),
+          GRPC_ERROR_INT_HTTP2_ERROR, (intptr_t)goaway_error),
+      GRPC_ERROR_STR_RAW_BYTES, goaway_text);
 
   /* When a client receives a GOAWAY with error code ENHANCE_YOUR_CALM and debug
    * data equal to "too_many_pings", it should log the occurrence at a log level
@@ -1144,14 +1156,8 @@ void grpc_chttp2_add_incoming_goaway(grpc_exec_ctx* exec_ctx,
 
   /* lie: use transient failure from the transport to indicate goaway has been
    * received */
-  connectivity_state_set(
-      exec_ctx, t, GRPC_CHANNEL_TRANSIENT_FAILURE,
-      grpc_error_set_str(
-          grpc_error_set_int(
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("GOAWAY received"),
-              GRPC_ERROR_INT_HTTP2_ERROR, (intptr_t)goaway_error),
-          GRPC_ERROR_STR_RAW_BYTES, goaway_text),
-      "got_goaway");
+  connectivity_state_set(exec_ctx, t, GRPC_CHANNEL_TRANSIENT_FAILURE,
+                         GRPC_ERROR_REF(t->goaway_error), "got_goaway");
 }
 
 static void maybe_start_some_streams(grpc_exec_ctx* exec_ctx,
@@ -1215,7 +1221,7 @@ static grpc_closure* add_closure_barrier(grpc_closure* closure) {
 static void null_then_run_closure(grpc_exec_ctx* exec_ctx,
                                   grpc_closure** closure, grpc_error* error) {
   grpc_closure* c = *closure;
-  *closure = NULL;
+  *closure = nullptr;
   GRPC_CLOSURE_RUN(exec_ctx, c, error);
 }
 
@@ -1225,8 +1231,8 @@ void grpc_chttp2_complete_closure_step(grpc_exec_ctx* exec_ctx,
                                        grpc_closure** pclosure,
                                        grpc_error* error, const char* desc) {
   grpc_closure* closure = *pclosure;
-  *pclosure = NULL;
-  if (closure == NULL) {
+  *pclosure = nullptr;
+  if (closure == nullptr) {
     GRPC_ERROR_UNREF(error);
     return;
   }
@@ -1256,7 +1262,7 @@ void grpc_chttp2_complete_closure_step(grpc_exec_ctx* exec_ctx,
   if (closure->next_data.scratch < CLOSURE_BARRIER_FIRST_REF_BIT) {
     if (closure->next_data.scratch & CLOSURE_BARRIER_STATS_BIT) {
       grpc_transport_move_stats(&s->stats, s->collecting_stats);
-      s->collecting_stats = NULL;
+      s->collecting_stats = nullptr;
     }
     if ((t->write_state == GRPC_CHTTP2_WRITE_STATE_IDLE) ||
         !(closure->next_data.scratch & CLOSURE_BARRIER_MAY_COVER_WRITE)) {
@@ -1269,7 +1275,7 @@ void grpc_chttp2_complete_closure_step(grpc_exec_ctx* exec_ctx,
 }
 
 static bool contains_non_ok_status(grpc_metadata_batch* batch) {
-  if (batch->idx.named.grpc_status != NULL) {
+  if (batch->idx.named.grpc_status != nullptr) {
     return !grpc_mdelem_eq(batch->idx.named.grpc_status->md,
                            GRPC_MDELEM_GRPC_STATUS_0);
   }
@@ -1300,7 +1306,7 @@ static void continue_fetching_send_locked(grpc_exec_ctx* exec_ctx,
                                           grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
   for (;;) {
-    if (s->fetching_send_message == NULL) {
+    if (s->fetching_send_message == nullptr) {
       /* Stream was cancelled before message fetch completed */
       abort(); /* TODO(ctiller): what cleanup here? */
       return;  /* early out */
@@ -1314,14 +1320,14 @@ static void continue_fetching_send_locked(grpc_exec_ctx* exec_ctx,
             "fetching_send_message_finished");
       } else {
         grpc_chttp2_write_cb* cb = t->write_cb_pool;
-        if (cb == NULL) {
+        if (cb == nullptr) {
           cb = (grpc_chttp2_write_cb*)gpr_malloc(sizeof(*cb));
         } else {
           t->write_cb_pool = cb->next;
         }
         cb->call_at_byte = notify_offset;
         cb->closure = s->fetching_send_message_finished;
-        s->fetching_send_message_finished = NULL;
+        s->fetching_send_message_finished = nullptr;
         grpc_chttp2_write_cb** list =
             s->fetching_send_message->flags & GRPC_WRITE_THROUGH
                 ? &s->on_write_finished_cbs
@@ -1329,7 +1335,7 @@ static void continue_fetching_send_locked(grpc_exec_ctx* exec_ctx,
         cb->next = *list;
         *list = cb;
       }
-      s->fetching_send_message = NULL;
+      s->fetching_send_message = nullptr;
       return; /* early out */
     } else if (grpc_byte_stream_next(exec_ctx, s->fetching_send_message,
                                      UINT32_MAX, &s->complete_fetch_locked)) {
@@ -1367,7 +1373,7 @@ static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
 static void log_metadata(const grpc_metadata_batch* md_batch, uint32_t id,
                          bool is_client, bool is_initial) {
-  for (grpc_linked_mdelem* md = md_batch->list.head; md != NULL;
+  for (grpc_linked_mdelem* md = md_batch->list.head; md != nullptr;
        md = md->next) {
     char* key = grpc_slice_to_c_string(GRPC_MDKEY(md->md));
     char* value = grpc_slice_to_c_string(GRPC_MDVALUE(md->md));
@@ -1406,9 +1412,9 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
   }
 
   grpc_closure* on_complete = op->on_complete;
-  if (on_complete == NULL) {
+  if (on_complete == nullptr) {
     on_complete =
-        GRPC_CLOSURE_CREATE(do_nothing, NULL, grpc_schedule_on_exec_ctx);
+        GRPC_CLOSURE_CREATE(do_nothing, nullptr, grpc_schedule_on_exec_ctx);
   }
 
   /* use final_data as a barrier until enqueue time; the inital counter is
@@ -1417,7 +1423,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
   on_complete->error_data.error = GRPC_ERROR_NONE;
 
   if (op->collect_stats) {
-    GPR_ASSERT(s->collecting_stats == NULL);
+    GPR_ASSERT(s->collecting_stats == nullptr);
     s->collecting_stats = op_payload->collect_stats.collect_stats;
     on_complete->next_data.scratch |= CLOSURE_BARRIER_STATS_BIT;
   }
@@ -1430,12 +1436,12 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
 
   if (op->send_initial_metadata) {
     GRPC_STATS_INC_HTTP2_OP_SEND_INITIAL_METADATA(exec_ctx);
-    GPR_ASSERT(s->send_initial_metadata_finished == NULL);
+    GPR_ASSERT(s->send_initial_metadata_finished == nullptr);
     on_complete->next_data.scratch |= CLOSURE_BARRIER_MAY_COVER_WRITE;
 
     /* Identify stream compression */
     if (op_payload->send_initial_metadata.send_initial_metadata->idx.named
-                .content_encoding == NULL ||
+                .content_encoding == nullptr ||
         grpc_stream_compression_method_parse(
             GRPC_MDVALUE(
                 op_payload->send_initial_metadata.send_initial_metadata->idx
@@ -1496,7 +1502,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
           }
         }
       } else {
-        s->send_initial_metadata = NULL;
+        s->send_initial_metadata = nullptr;
         grpc_chttp2_complete_closure_step(
             exec_ctx, t, s, &s->send_initial_metadata_finished,
             GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
@@ -1505,7 +1511,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
             "send_initial_metadata_finished");
       }
     }
-    if (op_payload->send_initial_metadata.peer_string != NULL) {
+    if (op_payload->send_initial_metadata.peer_string != nullptr) {
       gpr_atm_rel_store(op_payload->send_initial_metadata.peer_string,
                         (gpr_atm)gpr_strdup(t->peer_string));
     }
@@ -1532,7 +1538,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
                     &s->write_closed_error, 1),
           "fetching_send_message_finished");
     } else {
-      GPR_ASSERT(s->fetching_send_message == NULL);
+      GPR_ASSERT(s->fetching_send_message == nullptr);
       uint8_t* frame_hdr = grpc_slice_buffer_tiny_add(
           &s->flow_controlled_buffer, GRPC_HEADER_SIZE_IN_BYTES);
       uint32_t flags = op_payload->send_message.send_message->flags;
@@ -1560,7 +1566,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
 
   if (op->send_trailing_metadata) {
     GRPC_STATS_INC_HTTP2_OP_SEND_TRAILING_METADATA(exec_ctx);
-    GPR_ASSERT(s->send_trailing_metadata_finished == NULL);
+    GPR_ASSERT(s->send_trailing_metadata_finished == nullptr);
     on_complete->next_data.scratch |= CLOSURE_BARRIER_MAY_COVER_WRITE;
     s->send_trailing_metadata_finished = add_closure_barrier(on_complete);
     s->send_trailing_metadata =
@@ -1588,7 +1594,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
         s->seen_error = true;
       }
       if (s->write_closed) {
-        s->send_trailing_metadata = NULL;
+        s->send_trailing_metadata = nullptr;
         grpc_chttp2_complete_closure_step(
             exec_ctx, t, s, &s->send_trailing_metadata_finished,
             grpc_metadata_batch_is_empty(
@@ -1610,14 +1616,14 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
 
   if (op->recv_initial_metadata) {
     GRPC_STATS_INC_HTTP2_OP_RECV_INITIAL_METADATA(exec_ctx);
-    GPR_ASSERT(s->recv_initial_metadata_ready == NULL);
+    GPR_ASSERT(s->recv_initial_metadata_ready == nullptr);
     s->recv_initial_metadata_ready =
         op_payload->recv_initial_metadata.recv_initial_metadata_ready;
     s->recv_initial_metadata =
         op_payload->recv_initial_metadata.recv_initial_metadata;
     s->trailing_metadata_available =
         op_payload->recv_initial_metadata.trailing_metadata_available;
-    if (op_payload->recv_initial_metadata.peer_string != NULL) {
+    if (op_payload->recv_initial_metadata.peer_string != nullptr) {
       gpr_atm_rel_store(op_payload->recv_initial_metadata.peer_string,
                         (gpr_atm)gpr_strdup(t->peer_string));
     }
@@ -1627,7 +1633,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
   if (op->recv_message) {
     GRPC_STATS_INC_HTTP2_OP_RECV_MESSAGE(exec_ctx);
     size_t already_received;
-    GPR_ASSERT(s->recv_message_ready == NULL);
+    GPR_ASSERT(s->recv_message_ready == nullptr);
     GPR_ASSERT(!s->pending_byte_stream);
     s->recv_message_ready = op_payload->recv_message.recv_message_ready;
     s->recv_message = op_payload->recv_message.recv_message;
@@ -1645,7 +1651,7 @@ static void perform_stream_op_locked(grpc_exec_ctx* exec_ctx, void* stream_op,
 
   if (op->recv_trailing_metadata) {
     GRPC_STATS_INC_HTTP2_OP_RECV_TRAILING_METADATA(exec_ctx);
-    GPR_ASSERT(s->recv_trailing_metadata_finished == NULL);
+    GPR_ASSERT(s->recv_trailing_metadata_finished == nullptr);
     s->recv_trailing_metadata_finished = add_closure_barrier(on_complete);
     s->recv_trailing_metadata =
         op_payload->recv_trailing_metadata.recv_trailing_metadata;
@@ -1755,8 +1761,8 @@ static void send_goaway(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
   t->sent_goaway_state = GRPC_CHTTP2_GOAWAY_SEND_SCHEDULED;
   grpc_http2_error_code http_error;
   grpc_slice slice;
-  grpc_error_get_status(exec_ctx, error, GRPC_MILLIS_INF_FUTURE, NULL, &slice,
-                        &http_error);
+  grpc_error_get_status(exec_ctx, error, GRPC_MILLIS_INF_FUTURE, nullptr,
+                        &slice, &http_error);
   grpc_chttp2_goaway_append(t->last_new_stream_id, (uint32_t)http_error,
                             grpc_slice_ref_internal(slice), &t->qbuf);
   grpc_chttp2_initiate_write(exec_ctx, t,
@@ -1808,12 +1814,12 @@ static void perform_transport_op_locked(grpc_exec_ctx* exec_ctx,
   }
 
   if (op->send_ping) {
-    send_ping_locked(exec_ctx, t, NULL, op->send_ping);
+    send_ping_locked(exec_ctx, t, nullptr, op->send_ping);
     grpc_chttp2_initiate_write(exec_ctx, t,
                                GRPC_CHTTP2_INITIATE_WRITE_APPLICATION_PING);
   }
 
-  if (op->on_connectivity_state_change != NULL) {
+  if (op->on_connectivity_state_change != nullptr) {
     grpc_connectivity_state_notify_on_state_change(
         exec_ctx, &t->channel_callback.state_tracker, op->connectivity_state,
         op->on_connectivity_state_change);
@@ -1854,7 +1860,7 @@ static void perform_transport_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
 void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_exec_ctx* exec_ctx,
                                                       grpc_chttp2_transport* t,
                                                       grpc_chttp2_stream* s) {
-  if (s->recv_initial_metadata_ready != NULL &&
+  if (s->recv_initial_metadata_ready != nullptr &&
       s->published_metadata[0] != GRPC_METADATA_NOT_PUBLISHED) {
     if (s->seen_error) {
       grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &s->frame_storage);
@@ -1874,8 +1880,8 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_exec_ctx* exec_ctx,
                                              grpc_chttp2_transport* t,
                                              grpc_chttp2_stream* s) {
   grpc_error* error = GRPC_ERROR_NONE;
-  if (s->recv_message_ready != NULL) {
-    *s->recv_message = NULL;
+  if (s->recv_message_ready != nullptr) {
+    *s->recv_message = nullptr;
     if (s->final_metadata_requested && s->seen_error) {
       grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &s->frame_storage);
       if (!s->pending_byte_stream) {
@@ -1904,7 +1910,7 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_exec_ctx* exec_ctx,
           if (!grpc_stream_decompress(
                   s->stream_decompression_ctx,
                   &s->unprocessed_incoming_frames_buffer,
-                  &s->decompressed_data_buffer, NULL,
+                  &s->decompressed_data_buffer, nullptr,
                   GRPC_HEADER_SIZE_IN_BYTES - s->decompressed_header_bytes,
                   &end_of_context)) {
             grpc_slice_buffer_reset_and_unref_internal(exec_ctx,
@@ -1920,17 +1926,17 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_exec_ctx* exec_ctx,
             }
             error = grpc_deframe_unprocessed_incoming_frames(
                 exec_ctx, &s->data_parser, s, &s->decompressed_data_buffer,
-                NULL, s->recv_message);
+                nullptr, s->recv_message);
             if (end_of_context) {
               grpc_stream_compression_context_destroy(
                   s->stream_decompression_ctx);
-              s->stream_decompression_ctx = NULL;
+              s->stream_decompression_ctx = nullptr;
             }
           }
         } else {
           error = grpc_deframe_unprocessed_incoming_frames(
               exec_ctx, &s->data_parser, s,
-              &s->unprocessed_incoming_frames_buffer, NULL, s->recv_message);
+              &s->unprocessed_incoming_frames_buffer, nullptr, s->recv_message);
         }
         if (error != GRPC_ERROR_NONE) {
           s->seen_error = true;
@@ -1939,15 +1945,15 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_exec_ctx* exec_ctx,
           grpc_slice_buffer_reset_and_unref_internal(
               exec_ctx, &s->unprocessed_incoming_frames_buffer);
           break;
-        } else if (*s->recv_message != NULL) {
+        } else if (*s->recv_message != nullptr) {
           break;
         }
       }
     }
-    if (error == GRPC_ERROR_NONE && *s->recv_message != NULL) {
+    if (error == GRPC_ERROR_NONE && *s->recv_message != nullptr) {
       null_then_run_closure(exec_ctx, &s->recv_message_ready, GRPC_ERROR_NONE);
     } else if (s->published_metadata[1] != GRPC_METADATA_NOT_PUBLISHED) {
-      *s->recv_message = NULL;
+      *s->recv_message = nullptr;
       null_then_run_closure(exec_ctx, &s->recv_message_ready, GRPC_ERROR_NONE);
     }
     GRPC_ERROR_UNREF(error);
@@ -1958,7 +1964,7 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_exec_ctx* exec_ctx,
                                                        grpc_chttp2_transport* t,
                                                        grpc_chttp2_stream* s) {
   grpc_chttp2_maybe_complete_recv_message(exec_ctx, t, s);
-  if (s->recv_trailing_metadata_finished != NULL && s->read_closed &&
+  if (s->recv_trailing_metadata_finished != nullptr && s->read_closed &&
       s->write_closed) {
     if (s->seen_error) {
       grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &s->frame_storage);
@@ -1970,7 +1976,7 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_exec_ctx* exec_ctx,
     bool pending_data = s->pending_byte_stream ||
                         s->unprocessed_incoming_frames_buffer.length > 0;
     if (s->read_closed && s->frame_storage.length > 0 && !pending_data &&
-        !s->seen_error && s->recv_trailing_metadata_finished != NULL) {
+        !s->seen_error && s->recv_trailing_metadata_finished != nullptr) {
       /* Maybe some SYNC_FLUSH data is left in frame_storage. Consume them and
        * maybe decompress the next 5 bytes in the stream. */
       bool end_of_context;
@@ -1978,10 +1984,10 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_exec_ctx* exec_ctx,
         s->stream_decompression_ctx = grpc_stream_compression_context_create(
             s->stream_decompression_method);
       }
-      if (!grpc_stream_decompress(s->stream_decompression_ctx,
-                                  &s->frame_storage,
-                                  &s->unprocessed_incoming_frames_buffer, NULL,
-                                  GRPC_HEADER_SIZE_IN_BYTES, &end_of_context)) {
+      if (!grpc_stream_decompress(
+              s->stream_decompression_ctx, &s->frame_storage,
+              &s->unprocessed_incoming_frames_buffer, nullptr,
+              GRPC_HEADER_SIZE_IN_BYTES, &end_of_context)) {
         grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &s->frame_storage);
         grpc_slice_buffer_reset_and_unref_internal(
             exec_ctx, &s->unprocessed_incoming_frames_buffer);
@@ -1993,12 +1999,12 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_exec_ctx* exec_ctx,
         }
         if (end_of_context) {
           grpc_stream_compression_context_destroy(s->stream_decompression_ctx);
-          s->stream_decompression_ctx = NULL;
+          s->stream_decompression_ctx = nullptr;
         }
       }
     }
     if (s->read_closed && s->frame_storage.length == 0 && !pending_data &&
-        s->recv_trailing_metadata_finished != NULL) {
+        s->recv_trailing_metadata_finished != nullptr) {
       grpc_chttp2_incoming_metadata_buffer_publish(
           exec_ctx, &s->metadata_buffer[1], s->recv_trailing_metadata);
       grpc_chttp2_complete_closure_step(
@@ -2014,18 +2020,18 @@ static void remove_stream(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
       (grpc_chttp2_stream*)grpc_chttp2_stream_map_delete(&t->stream_map, id);
   GPR_ASSERT(s);
   if (t->incoming_stream == s) {
-    t->incoming_stream = NULL;
+    t->incoming_stream = nullptr;
     grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);
   }
   if (s->pending_byte_stream) {
-    if (s->on_next != NULL) {
+    if (s->on_next != nullptr) {
       grpc_chttp2_incoming_byte_stream* bs = s->data_parser.parsing_frame;
       if (error == GRPC_ERROR_NONE) {
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Truncated message");
       }
       incoming_byte_stream_publish_error(exec_ctx, bs, error);
       incoming_byte_stream_unref(exec_ctx, bs);
-      s->data_parser.parsing_frame = NULL;
+      s->data_parser.parsing_frame = nullptr;
     } else {
       GRPC_ERROR_UNREF(s->byte_stream_error);
       s->byte_stream_error = GRPC_ERROR_REF(error);
@@ -2062,8 +2068,8 @@ void grpc_chttp2_cancel_stream(grpc_exec_ctx* exec_ctx,
   if (!s->read_closed || !s->write_closed) {
     if (s->id != 0) {
       grpc_http2_error_code http_error;
-      grpc_error_get_status(exec_ctx, due_to_error, s->deadline, NULL, NULL,
-                            &http_error);
+      grpc_error_get_status(exec_ctx, due_to_error, s->deadline, nullptr,
+                            nullptr, &http_error);
       grpc_slice_buffer_add(
           &t->qbuf, grpc_chttp2_rst_stream_create(s->id, (uint32_t)http_error,
                                                   &s->stats.outgoing));
@@ -2081,8 +2087,7 @@ void grpc_chttp2_fake_status(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
                              grpc_chttp2_stream* s, grpc_error* error) {
   grpc_status_code status;
   grpc_slice slice;
-  grpc_error_get_status(exec_ctx, error, s->deadline, &status, &slice, NULL);
-
+  grpc_error_get_status(exec_ctx, error, s->deadline, &status, &slice, nullptr);
   if (status != GRPC_STATUS_OK) {
     s->seen_error = true;
   }
@@ -2093,7 +2098,7 @@ void grpc_chttp2_fake_status(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
      what we want - which is safe because we haven't told anyone
      about the metadata yet */
   if (s->published_metadata[1] == GRPC_METADATA_NOT_PUBLISHED ||
-      s->recv_trailing_metadata_finished != NULL) {
+      s->recv_trailing_metadata_finished != nullptr) {
     char status_string[GPR_LTOA_MIN_BUFSIZE];
     gpr_ltoa(status, status_string);
     GRPC_LOG_IF_ERROR("add_status",
@@ -2164,17 +2169,17 @@ void grpc_chttp2_fail_pending_writes(grpc_exec_ctx* exec_ctx,
                                      grpc_chttp2_stream* s, grpc_error* error) {
   error =
       removal_error(error, s, "Pending writes failed due to stream closure");
-  s->send_initial_metadata = NULL;
+  s->send_initial_metadata = nullptr;
   grpc_chttp2_complete_closure_step(
       exec_ctx, t, s, &s->send_initial_metadata_finished, GRPC_ERROR_REF(error),
       "send_initial_metadata_finished");
 
-  s->send_trailing_metadata = NULL;
+  s->send_trailing_metadata = nullptr;
   grpc_chttp2_complete_closure_step(
       exec_ctx, t, s, &s->send_trailing_metadata_finished,
       GRPC_ERROR_REF(error), "send_trailing_metadata_finished");
 
-  s->fetching_send_message = NULL;
+  s->fetching_send_message = nullptr;
   grpc_chttp2_complete_closure_step(
       exec_ctx, t, s, &s->fetching_send_message_finished, GRPC_ERROR_REF(error),
       "fetching_send_message_finished");
@@ -2247,7 +2252,7 @@ static void close_from_api(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
   grpc_status_code grpc_status;
   grpc_slice slice;
   grpc_error_get_status(exec_ctx, error, s->deadline, &grpc_status, &slice,
-                        NULL);
+                        nullptr);
 
   GPR_ASSERT(grpc_status >= 0 && (int)grpc_status < 100);
 
@@ -2471,7 +2476,7 @@ static grpc_error* try_http_parsing(grpc_exec_ctx* exec_ctx,
   grpc_error* parse_error = GRPC_ERROR_NONE;
   for (; i < t->read_buffer.count && parse_error == GRPC_ERROR_NONE; i++) {
     parse_error =
-        grpc_http_parser_parse(&parser, t->read_buffer.slices[i], NULL);
+        grpc_http_parser_parse(&parser, t->read_buffer.slices[i], nullptr);
   }
   if (parse_error == GRPC_ERROR_NONE &&
       (parse_error = grpc_http_parser_eof(&parser)) == GRPC_ERROR_NONE) {
@@ -2550,6 +2555,12 @@ static void read_action_locked(grpc_exec_ctx* exec_ctx, void* tp,
         "Transport closed", &t->closed_with_error, 1);
   }
   if (error != GRPC_ERROR_NONE) {
+    /* If a goaway frame was received, this might be the reason why the read
+     * failed. Add this info to the error */
+    if (t->goaway_error != GRPC_ERROR_NONE) {
+      error = grpc_error_add_child(error, GRPC_ERROR_REF(t->goaway_error));
+    }
+
     close_transport_locked(exec_ctx, t, GRPC_ERROR_REF(error));
     t->endpoint_reading = 0;
   } else if (t->closed_with_error == GRPC_ERROR_NONE) {
@@ -2562,7 +2573,7 @@ static void read_action_locked(grpc_exec_ctx* exec_ctx, void* tp,
     grpc_endpoint_read(exec_ctx, t->ep, &t->read_buffer,
                        &t->read_action_locked);
     grpc_chttp2_act_on_flowctl_action(exec_ctx, t->flow_control->MakeAction(),
-                                      t, NULL);
+                                      t, nullptr);
     GRPC_CHTTP2_UNREF_TRANSPORT(exec_ctx, t, "keep_reading");
   } else {
     GRPC_CHTTP2_UNREF_TRANSPORT(exec_ctx, t, "reading_action");
@@ -2813,7 +2824,7 @@ static void reset_byte_stream(grpc_exec_ctx* exec_ctx, void* arg,
   } else {
     GPR_ASSERT(error != GRPC_ERROR_NONE);
     GRPC_CLOSURE_SCHED(exec_ctx, s->on_next, GRPC_ERROR_REF(error));
-    s->on_next = NULL;
+    s->on_next = nullptr;
     GRPC_ERROR_UNREF(s->byte_stream_error);
     s->byte_stream_error = GRPC_ERROR_NONE;
     grpc_chttp2_cancel_stream(exec_ctx, s->t, s, GRPC_ERROR_REF(error));
@@ -2852,9 +2863,9 @@ static void incoming_byte_stream_next_locked(grpc_exec_ctx* exec_ctx,
   } else if (s->byte_stream_error != GRPC_ERROR_NONE) {
     GRPC_CLOSURE_SCHED(exec_ctx, bs->next_action.on_complete,
                        GRPC_ERROR_REF(s->byte_stream_error));
-    if (s->data_parser.parsing_frame != NULL) {
+    if (s->data_parser.parsing_frame != nullptr) {
       incoming_byte_stream_unref(exec_ctx, s->data_parser.parsing_frame);
-      s->data_parser.parsing_frame = NULL;
+      s->data_parser.parsing_frame = nullptr;
     }
   } else if (s->read_closed) {
     if (bs->remaining_bytes != 0) {
@@ -2862,9 +2873,9 @@ static void incoming_byte_stream_next_locked(grpc_exec_ctx* exec_ctx,
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Truncated message");
       GRPC_CLOSURE_SCHED(exec_ctx, bs->next_action.on_complete,
                          GRPC_ERROR_REF(s->byte_stream_error));
-      if (s->data_parser.parsing_frame != NULL) {
+      if (s->data_parser.parsing_frame != nullptr) {
         incoming_byte_stream_unref(exec_ctx, s->data_parser.parsing_frame);
-        s->data_parser.parsing_frame = NULL;
+        s->data_parser.parsing_frame = nullptr;
       }
     } else {
       /* Should never reach here. */
@@ -2920,7 +2931,7 @@ static grpc_error* incoming_byte_stream_pull(grpc_exec_ctx* exec_ctx,
       }
       if (!grpc_stream_decompress(s->stream_decompression_ctx,
                                   &s->unprocessed_incoming_frames_buffer,
-                                  &s->decompressed_data_buffer, NULL,
+                                  &s->decompressed_data_buffer, nullptr,
                                   MAX_SIZE_T, &end_of_context)) {
         error =
             GRPC_ERROR_CREATE_FROM_STATIC_STRING("Stream decompression error.");
@@ -2932,7 +2943,7 @@ static grpc_error* incoming_byte_stream_pull(grpc_exec_ctx* exec_ctx,
       s->unprocessed_incoming_frames_decompressed = true;
       if (end_of_context) {
         grpc_stream_compression_context_destroy(s->stream_decompression_ctx);
-        s->stream_decompression_ctx = NULL;
+        s->stream_decompression_ctx = nullptr;
       }
       if (s->unprocessed_incoming_frames_buffer.length == 0) {
         *slice = grpc_empty_slice();
@@ -2940,7 +2951,7 @@ static grpc_error* incoming_byte_stream_pull(grpc_exec_ctx* exec_ctx,
     }
     error = grpc_deframe_unprocessed_incoming_frames(
         exec_ctx, &s->data_parser, s, &s->unprocessed_incoming_frames_buffer,
-        slice, NULL);
+        slice, nullptr);
     if (error != GRPC_ERROR_NONE) {
       return error;
     }
@@ -2978,7 +2989,7 @@ static void incoming_byte_stream_publish_error(
 
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GRPC_CLOSURE_SCHED(exec_ctx, s->on_next, GRPC_ERROR_REF(error));
-  s->on_next = NULL;
+  s->on_next = nullptr;
   GRPC_ERROR_UNREF(s->byte_stream_error);
   s->byte_stream_error = GRPC_ERROR_REF(error);
   grpc_chttp2_cancel_stream(exec_ctx, bs->transport, bs->stream,
@@ -2999,7 +3010,7 @@ grpc_error* grpc_chttp2_incoming_byte_stream_push(
     return error;
   } else {
     bs->remaining_bytes -= (uint32_t)GRPC_SLICE_LENGTH(slice);
-    if (slice_out != NULL) {
+    if (slice_out != nullptr) {
       *slice_out = slice;
     }
     return GRPC_ERROR_NONE;

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

@@ -32,13 +32,13 @@
 
 grpc_error* grpc_chttp2_data_parser_init(grpc_chttp2_data_parser* parser) {
   parser->state = GRPC_CHTTP2_DATA_FH_0;
-  parser->parsing_frame = NULL;
+  parser->parsing_frame = nullptr;
   return GRPC_ERROR_NONE;
 }
 
 void grpc_chttp2_data_parser_destroy(grpc_exec_ctx* exec_ctx,
                                      grpc_chttp2_data_parser* parser) {
-  if (parser->parsing_frame != NULL) {
+  if (parser->parsing_frame != nullptr) {
     GRPC_ERROR_UNREF(grpc_chttp2_incoming_byte_stream_finished(
         exec_ctx, parser->parsing_frame,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Parser destroyed"), false));
@@ -105,9 +105,9 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
   grpc_chttp2_transport* t = s->t;
 
   while (slices->count > 0) {
-    uint8_t* beg = NULL;
-    uint8_t* end = NULL;
-    uint8_t* cur = NULL;
+    uint8_t* beg = nullptr;
+    uint8_t* end = nullptr;
+    uint8_t* cur = nullptr;
 
     grpc_slice slice = grpc_slice_buffer_take_first(slices);
 
@@ -188,8 +188,8 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
       /* fallthrough */
       case GRPC_CHTTP2_DATA_FH_4:
         s->stats.incoming.framing_bytes++;
-        GPR_ASSERT(stream_out != NULL);
-        GPR_ASSERT(p->parsing_frame == NULL);
+        GPR_ASSERT(stream_out != nullptr);
+        GPR_ASSERT(p->parsing_frame == nullptr);
         p->frame_size |= ((uint32_t)*cur);
         p->state = GRPC_CHTTP2_DATA_FRAME;
         ++cur;
@@ -203,7 +203,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         if (p->parsing_frame->remaining_bytes == 0) {
           GRPC_ERROR_UNREF(grpc_chttp2_incoming_byte_stream_finished(
               exec_ctx, p->parsing_frame, GRPC_ERROR_NONE, true));
-          p->parsing_frame = NULL;
+          p->parsing_frame = nullptr;
           p->state = GRPC_CHTTP2_DATA_FH_0;
         }
         s->pending_byte_stream = true;
@@ -216,8 +216,8 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
         grpc_slice_unref_internal(exec_ctx, slice);
         return GRPC_ERROR_NONE;
       case GRPC_CHTTP2_DATA_FRAME: {
-        GPR_ASSERT(p->parsing_frame != NULL);
-        GPR_ASSERT(slice_out != NULL);
+        GPR_ASSERT(p->parsing_frame != nullptr);
+        GPR_ASSERT(slice_out != nullptr);
         if (cur == end) {
           grpc_slice_unref_internal(exec_ctx, slice);
           continue;
@@ -239,7 +239,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
             grpc_slice_unref_internal(exec_ctx, slice);
             return error;
           }
-          p->parsing_frame = NULL;
+          p->parsing_frame = nullptr;
           p->state = GRPC_CHTTP2_DATA_FH_0;
           grpc_slice_unref_internal(exec_ctx, slice);
           return GRPC_ERROR_NONE;
@@ -273,7 +273,7 @@ grpc_error* grpc_deframe_unprocessed_incoming_frames(
             grpc_slice_unref_internal(exec_ctx, slice);
             return error;
           }
-          p->parsing_frame = NULL;
+          p->parsing_frame = nullptr;
           p->state = GRPC_CHTTP2_DATA_FH_0;
           cur += p->frame_size;
           grpc_slice_buffer_undo_take_first(
@@ -302,7 +302,7 @@ grpc_error* grpc_chttp2_data_parser_parse(grpc_exec_ctx* exec_ctx, void* parser,
     grpc_slice_ref_internal(slice);
     grpc_slice_buffer_add(&s->unprocessed_incoming_frames_buffer, slice);
     GRPC_CLOSURE_SCHED(exec_ctx, s->on_next, GRPC_ERROR_NONE);
-    s->on_next = NULL;
+    s->on_next = nullptr;
     s->unprocessed_incoming_frames_decompressed = false;
   } else {
     grpc_slice_ref_internal(slice);

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

@@ -26,7 +26,7 @@
 #include <grpc/support/string_util.h>
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
-  p->debug_data = NULL;
+  p->debug_data = nullptr;
 }
 
 void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser* p) {
@@ -137,7 +137,7 @@ grpc_error* grpc_chttp2_goaway_parser_parse(grpc_exec_ctx* exec_ctx,
         grpc_chttp2_add_incoming_goaway(
             exec_ctx, t, (uint32_t)p->error_code,
             grpc_slice_new(p->debug_data, p->debug_length, gpr_free));
-        p->debug_data = NULL;
+        p->debug_data = nullptr;
       }
       return GRPC_ERROR_NONE;
   }

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

@@ -79,7 +79,7 @@ grpc_error* grpc_chttp2_window_update_parser_parse(
     p->byte++;
   }
 
-  if (s != NULL) {
+  if (s != nullptr) {
     s->stats.incoming.framing_bytes += (uint32_t)(end - cur);
   }
 
@@ -95,7 +95,7 @@ grpc_error* grpc_chttp2_window_update_parser_parse(
     GPR_ASSERT(is_last);
 
     if (t->incoming_stream_id != 0) {
-      if (s != NULL) {
+      if (s != nullptr) {
         s->flow_control->RecvUpdate(received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
           grpc_chttp2_mark_stream_writable(exec_ctx, t, s);

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

@@ -51,10 +51,10 @@
 /* don't consider adding anything bigger than this to the hpack table */
 #define MAX_DECODER_SPACE_USAGE 512
 
-static grpc_slice_refcount terminal_slice_refcount = {NULL, NULL};
+static grpc_slice_refcount terminal_slice_refcount = {nullptr, nullptr};
 static const grpc_slice terminal_slice = {
     &terminal_slice_refcount, /* refcount */
-    {{0, 0}}                  /* data.refcounted */
+    {{nullptr, 0}}            /* data.refcounted */
 };
 
 extern "C" grpc_tracer_flag grpc_http_trace;
@@ -477,7 +477,7 @@ static void hpack_enc(grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_compressor* c,
 
   if (GRPC_TRACER_ON(grpc_http_trace)) {
     char* k = grpc_slice_to_c_string(GRPC_MDKEY(elem));
-    char* v = NULL;
+    char* v = nullptr;
     if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
       v = grpc_dump_slice(GRPC_MDVALUE(elem), GPR_DUMP_HEX);
     } else {

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

@@ -653,7 +653,7 @@ static grpc_error* on_hdr(grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p,
                           grpc_mdelem md, int add_to_table) {
   if (GRPC_TRACER_ON(grpc_http_trace)) {
     char* k = grpc_slice_to_c_string(GRPC_MDKEY(md));
-    char* v = NULL;
+    char* v = nullptr;
     if (grpc_is_binary_header(GRPC_MDKEY(md))) {
       v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX);
     } else {
@@ -674,7 +674,7 @@ static grpc_error* on_hdr(grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p,
     grpc_error* err = grpc_chttp2_hptbl_add(exec_ctx, &p->table, md);
     if (err != GRPC_ERROR_NONE) return err;
   }
-  if (p->on_header == NULL) {
+  if (p->on_header == nullptr) {
     GRPC_MDELEM_UNREF(exec_ctx, md);
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("on_header callback not set");
   }
@@ -1523,7 +1523,7 @@ static grpc_error* begin_parse_string(grpc_exec_ctx* exec_ctx,
                                       uint8_t binary,
                                       grpc_chttp2_hpack_parser_string* str) {
   if (!p->huff && binary == NOT_BINARY && (end - cur) >= (intptr_t)p->strlen &&
-      p->current_slice_refcount != NULL) {
+      p->current_slice_refcount != nullptr) {
     GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx);
     str->copied = false;
     str->data.referenced.refcount = p->current_slice_refcount;
@@ -1613,15 +1613,15 @@ static grpc_error* parse_value_string_with_literal_key(
 
 void grpc_chttp2_hpack_parser_init(grpc_exec_ctx* exec_ctx,
                                    grpc_chttp2_hpack_parser* p) {
-  p->on_header = NULL;
-  p->on_header_user_data = NULL;
+  p->on_header = nullptr;
+  p->on_header_user_data = nullptr;
   p->state = parse_begin;
   p->key.data.referenced = grpc_empty_slice();
-  p->key.data.copied.str = NULL;
+  p->key.data.copied.str = nullptr;
   p->key.data.copied.capacity = 0;
   p->key.data.copied.length = 0;
   p->value.data.referenced = grpc_empty_slice();
-  p->value.data.copied.str = NULL;
+  p->value.data.copied.str = nullptr;
   p->value.data.copied.capacity = 0;
   p->value.data.copied.length = 0;
   p->dynamic_table_update_allowed = 2;
@@ -1659,7 +1659,7 @@ grpc_error* grpc_chttp2_hpack_parser_parse(grpc_exec_ctx* exec_ctx,
     error = p->state(exec_ctx, p, start, target);
     start = target;
   }
-  p->current_slice_refcount = NULL;
+  p->current_slice_refcount = nullptr;
   return error;
 }
 
@@ -1689,7 +1689,7 @@ static void parse_stream_compression_md(grpc_exec_ctx* exec_ctx,
                                         grpc_chttp2_transport* t,
                                         grpc_chttp2_stream* s,
                                         grpc_metadata_batch* initial_metadata) {
-  if (initial_metadata->idx.named.content_encoding == NULL ||
+  if (initial_metadata->idx.named.content_encoding == nullptr ||
       grpc_stream_compression_method_parse(
           GRPC_MDVALUE(initial_metadata->idx.named.content_encoding->md), false,
           &s->stream_decompression_method) == 0) {
@@ -1705,7 +1705,7 @@ grpc_error* grpc_chttp2_header_parser_parse(grpc_exec_ctx* exec_ctx,
                                             grpc_slice slice, int is_last) {
   grpc_chttp2_hpack_parser* parser = (grpc_chttp2_hpack_parser*)hpack_parser;
   GPR_TIMER_BEGIN("grpc_chttp2_hpack_parser_parse", 0);
-  if (s != NULL) {
+  if (s != nullptr) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error* error = grpc_chttp2_hpack_parser_parse(exec_ctx, parser, slice);
@@ -1721,7 +1721,7 @@ grpc_error* grpc_chttp2_header_parser_parse(grpc_exec_ctx* exec_ctx,
     }
     /* need to check for null stream: this can occur if we receive an invalid
        stream id on a header */
-    if (s != NULL) {
+    if (s != nullptr) {
       if (parser->is_boundary) {
         if (s->header_frames_received == GPR_ARRAY_SIZE(s->metadata_buffer)) {
           GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
@@ -1756,8 +1756,8 @@ grpc_error* grpc_chttp2_header_parser_parse(grpc_exec_ctx* exec_ctx,
                                        GRPC_ERROR_NONE);
       }
     }
-    parser->on_header = NULL;
-    parser->on_header_user_data = NULL;
+    parser->on_header = nullptr;
+    parser->on_header_user_data = nullptr;
     parser->is_boundary = 0xde;
     parser->is_eof = 0xde;
     parser->dynamic_table_update_allowed = 2;

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

@@ -35,7 +35,7 @@ static struct {
   const char* value;
 } static_table[] = {
     /* 0: */
-    {NULL, NULL},
+    {nullptr, nullptr},
     /* 1: */
     {":authority", ""},
     /* 2: */

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

@@ -51,7 +51,7 @@ grpc_error* grpc_chttp2_incoming_metadata_buffer_add(
 grpc_error* grpc_chttp2_incoming_metadata_buffer_replace_or_add(
     grpc_exec_ctx* exec_ctx, grpc_chttp2_incoming_metadata_buffer* buffer,
     grpc_mdelem elem) {
-  for (grpc_linked_mdelem* l = buffer->batch.list.head; l != NULL;
+  for (grpc_linked_mdelem* l = buffer->batch.list.head; l != nullptr;
        l = l->next) {
     if (grpc_slice_eq(GRPC_MDKEY(l->md), GRPC_MDKEY(elem))) {
       GRPC_MDELEM_UNREF(exec_ctx, l->md);

src/core/ext/transport/chttp2/transport/internal.h

@@ -308,9 +308,10 @@ struct grpc_chttp2_transport {
    */
   uint32_t write_buffer_size;
 
-  /** have we seen a goaway */
-  bool seen_goaway;
-  /** have we sent a goaway */
+  /** Set to a grpc_error object if a goaway frame is received. By default, set
+   * to GRPC_ERROR_NONE */
+  grpc_error* goaway_error;
+
   grpc_chttp2_sent_goaway_state sent_goaway_state;
 
   /** are the local settings dirty and need to be sent? */
@@ -378,11 +379,6 @@ struct grpc_chttp2_transport {
                         grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                         grpc_slice slice, int is_last);
 
-  /* goaway data */
-  grpc_status_code goaway_error;
-  uint32_t goaway_last_stream_index;
-  grpc_slice goaway_text;
-
   grpc_chttp2_write_cb* write_cb_pool;
 
   /* bdp estimator */

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

@@ -191,7 +191,7 @@ grpc_error* grpc_chttp2_perform_read(grpc_exec_ctx* exec_ctx,
         if (err != GRPC_ERROR_NONE) {
           return err;
         }
-        t->incoming_stream = NULL;
+        t->incoming_stream = nullptr;
         if (++cur == end) {
           t->deframe_state = GRPC_DTS_FH_0;
           return GRPC_ERROR_NONE;
@@ -225,7 +225,7 @@ grpc_error* grpc_chttp2_perform_read(grpc_exec_ctx* exec_ctx,
           return err;
         }
         t->deframe_state = GRPC_DTS_FH_0;
-        t->incoming_stream = NULL;
+        t->incoming_stream = nullptr;
         return GRPC_ERROR_NONE;
       } else if ((uint32_t)(end - cur) > t->incoming_frame_size) {
         size_t cur_offset = (size_t)(cur - beg);
@@ -238,7 +238,7 @@ grpc_error* grpc_chttp2_perform_read(grpc_exec_ctx* exec_ctx,
           return err;
         }
         cur += t->incoming_frame_size;
-        t->incoming_stream = NULL;
+        t->incoming_stream = nullptr;
         goto dts_fh_0; /* loop */
       } else {
         err =
@@ -252,10 +252,10 @@ grpc_error* grpc_chttp2_perform_read(grpc_exec_ctx* exec_ctx,
         t->incoming_frame_size -= (uint32_t)(end - cur);
         return GRPC_ERROR_NONE;
       }
-      GPR_UNREACHABLE_CODE(return 0);
+      GPR_UNREACHABLE_CODE(return nullptr);
   }
 
-  GPR_UNREACHABLE_CODE(return 0);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
 static grpc_error* init_frame_parser(grpc_exec_ctx* exec_ctx,
@@ -337,7 +337,7 @@ static grpc_error* init_skip_frame_parser(grpc_exec_ctx* exec_ctx,
     t->parser = grpc_chttp2_header_parser_parse;
     t->parser_data = &t->hpack_parser;
     t->hpack_parser.on_header = skip_header;
-    t->hpack_parser.on_header_user_data = NULL;
+    t->hpack_parser.on_header_user_data = nullptr;
     t->hpack_parser.is_boundary = is_eoh;
     t->hpack_parser.is_eof = (uint8_t)(is_eoh ? t->header_eof : 0);
   } else {
@@ -369,7 +369,7 @@ static grpc_error* init_data_frame_parser(grpc_exec_ctx* exec_ctx,
   if (err != GRPC_ERROR_NONE) {
     goto error_handler;
   }
-  if (s == NULL) {
+  if (s == nullptr) {
     return init_skip_frame_parser(exec_ctx, t, 0);
   }
   s->received_bytes += t->incoming_frame_size;
@@ -391,9 +391,9 @@ error_handler:
         t->ping_policy.max_pings_without_data;
     t->ping_state.last_ping_sent_time = GRPC_MILLIS_INF_PAST;
     return GRPC_ERROR_NONE;
-  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, NULL)) {
+  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, nullptr)) {
     /* handle stream errors by closing the stream */
-    if (s != NULL) {
+    if (s != nullptr) {
       grpc_chttp2_mark_stream_closed(exec_ctx, t, s, true, false, err);
     }
     grpc_slice_buffer_add(
@@ -415,7 +415,7 @@ static void on_initial_header(grpc_exec_ctx* exec_ctx, void* tp,
 
   GPR_TIMER_BEGIN("on_initial_header", 0);
 
-  GPR_ASSERT(s != NULL);
+  GPR_ASSERT(s != nullptr);
 
   if (GRPC_TRACER_ON(grpc_http_trace)) {
     char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
@@ -437,7 +437,7 @@ static void on_initial_header(grpc_exec_ctx* exec_ctx, void* tp,
     grpc_millis* cached_timeout =
         static_cast<grpc_millis*>(grpc_mdelem_get_user_data(md, free_timeout));
     grpc_millis timeout;
-    if (cached_timeout != NULL) {
+    if (cached_timeout != nullptr) {
       timeout = *cached_timeout;
     } else {
       if (!grpc_http2_decode_timeout(GRPC_MDVALUE(md), &timeout)) {
@@ -499,7 +499,7 @@ static void on_trailing_header(grpc_exec_ctx* exec_ctx, void* tp,
 
   GPR_TIMER_BEGIN("on_trailing_header", 0);
 
-  GPR_ASSERT(s != NULL);
+  GPR_ASSERT(s != nullptr);
 
   if (GRPC_TRACER_ON(grpc_http_trace)) {
     char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
@@ -575,7 +575,7 @@ static grpc_error* init_header_frame_parser(grpc_exec_ctx* exec_ctx,
 
   /* could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream */
   s = grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
-  if (s == NULL) {
+  if (s == nullptr) {
     if (is_continuation) {
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR,
@@ -590,7 +590,11 @@ static grpc_error* init_header_frame_parser(grpc_exec_ctx* exec_ctx,
         GRPC_CHTTP2_IF_TRACING(gpr_log(
             GPR_ERROR, "ignoring new grpc_chttp2_stream creation on client"));
       }
-      return init_skip_frame_parser(exec_ctx, t, 1);
+      grpc_error* err = init_skip_frame_parser(exec_ctx, t, 1);
+      if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_HAS_PRIORITY) {
+        grpc_chttp2_hpack_parser_set_has_priority(&t->hpack_parser);
+      }
+      return err;
     } else if (t->last_new_stream_id >= t->incoming_stream_id) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_ERROR,
@@ -613,7 +617,7 @@ static grpc_error* init_header_frame_parser(grpc_exec_ctx* exec_ctx,
     t->last_new_stream_id = t->incoming_stream_id;
     s = t->incoming_stream =
         grpc_chttp2_parsing_accept_stream(exec_ctx, t, t->incoming_stream_id);
-    if (s == NULL) {
+    if (s == nullptr) {
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
       return init_skip_frame_parser(exec_ctx, t, 1);
@@ -621,12 +625,12 @@ static grpc_error* init_header_frame_parser(grpc_exec_ctx* exec_ctx,
   } else {
     t->incoming_stream = s;
   }
-  GPR_ASSERT(s != NULL);
+  GPR_ASSERT(s != nullptr);
   s->stats.incoming.framing_bytes += 9;
   if (s->read_closed) {
     GRPC_CHTTP2_IF_TRACING(gpr_log(
         GPR_ERROR, "skipping already closed grpc_chttp2_stream header"));
-    t->incoming_stream = NULL;
+    t->incoming_stream = nullptr;
     return init_skip_frame_parser(exec_ctx, t, 1);
   }
   t->parser = grpc_chttp2_header_parser_parse;
@@ -635,7 +639,7 @@ static grpc_error* init_header_frame_parser(grpc_exec_ctx* exec_ctx,
     case 0:
       if (t->is_client && t->header_eof) {
         GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing Trailers-Only"));
-        if (s->trailing_metadata_available != NULL) {
+        if (s->trailing_metadata_available != nullptr) {
           *s->trailing_metadata_available = true;
         }
         t->hpack_parser.on_header = on_trailing_header;
@@ -673,7 +677,7 @@ static grpc_error* init_window_update_frame_parser(grpc_exec_ctx* exec_ctx,
   if (t->incoming_stream_id != 0) {
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
-    if (s == NULL) {
+    if (s == nullptr) {
       return init_skip_frame_parser(exec_ctx, t, 0);
     }
     s->stats.incoming.framing_bytes += 9;
@@ -753,7 +757,7 @@ static grpc_error* parse_frame_slice(grpc_exec_ctx* exec_ctx,
   grpc_error* err = t->parser(exec_ctx, t->parser_data, t, s, slice, is_last);
   if (err == GRPC_ERROR_NONE) {
     return err;
-  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, NULL)) {
+  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, nullptr)) {
     if (GRPC_TRACER_ON(grpc_http_trace)) {
       const char* msg = grpc_error_string(err);
       gpr_log(GPR_ERROR, "%s", msg);

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

@@ -46,7 +46,7 @@ grpc_tracer_flag grpc_trace_http2_stream_state =
 
 static bool stream_list_empty(grpc_chttp2_transport* t,
                               grpc_chttp2_stream_list_id id) {
-  return t->lists[id].head == NULL;
+  return t->lists[id].head == nullptr;
 }
 
 static bool stream_list_pop(grpc_chttp2_transport* t,
@@ -58,10 +58,10 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
     GPR_ASSERT(s->included[id]);
     if (new_head) {
       t->lists[id].head = new_head;
-      new_head->links[id].prev = NULL;
+      new_head->links[id].prev = nullptr;
     } else {
-      t->lists[id].head = NULL;
-      t->lists[id].tail = NULL;
+      t->lists[id].head = nullptr;
+      t->lists[id].tail = nullptr;
     }
     s->included[id] = 0;
   }
@@ -70,7 +70,7 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
     gpr_log(GPR_DEBUG, "%p[%d][%s]: pop from %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
-  return s != 0;
+  return s != nullptr;
 }
 
 static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
@@ -111,7 +111,7 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
   grpc_chttp2_stream* old_tail;
   GPR_ASSERT(!s->included[id]);
   old_tail = t->lists[id].tail;
-  s->links[id].next = NULL;
+  s->links[id].next = nullptr;
   s->links[id].prev = old_tail;
   if (old_tail) {
     old_tail->links[id].next = s;

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

@@ -62,7 +62,7 @@ void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map* map, uint32_t key,
 
   GPR_ASSERT(count == 0 || keys[count - 1] < key);
   GPR_ASSERT(value);
-  GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == NULL);
+  GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == nullptr);
 
   if (count == capacity) {
     if (map->free > capacity / 4) {
@@ -92,7 +92,7 @@ static void** find(grpc_chttp2_stream_map* map, uint32_t key) {
   void** values = map->values;
   uint32_t mid_key;
 
-  if (max_idx == 0) return NULL;
+  if (max_idx == 0) return nullptr;
 
   while (min_idx < max_idx) {
     /* find the midpoint, avoiding overflow */
@@ -109,29 +109,29 @@ static void** find(grpc_chttp2_stream_map* map, uint32_t key) {
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void* grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map* map, uint32_t key) {
   void** pvalue = find(map, key);
-  void* out = NULL;
-  if (pvalue != NULL) {
+  void* out = nullptr;
+  if (pvalue != nullptr) {
     out = *pvalue;
-    *pvalue = NULL;
-    map->free += (out != NULL);
+    *pvalue = nullptr;
+    map->free += (out != nullptr);
     /* recognize complete emptyness and ensure we can skip
      * defragmentation later */
     if (map->free == map->count) {
       map->free = map->count = 0;
     }
-    GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == NULL);
+    GPR_ASSERT(grpc_chttp2_stream_map_find(map, key) == nullptr);
   }
   return out;
 }
 
 void* grpc_chttp2_stream_map_find(grpc_chttp2_stream_map* map, uint32_t key) {
   void** pvalue = find(map, key);
-  return pvalue != NULL ? *pvalue : NULL;
+  return pvalue != nullptr ? *pvalue : nullptr;
 }
 
 size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map* map) {
@@ -140,11 +140,12 @@ size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map* map) {
 
 void* grpc_chttp2_stream_map_rand(grpc_chttp2_stream_map* map) {
   if (map->count == map->free) {
-    return NULL;
+    return nullptr;
   }
   if (map->free != 0) {
     map->count = compact(map->keys, map->values, map->count);
     map->free = 0;
+    GPR_ASSERT(map->count > 0);
   }
   return map->values[((size_t)rand()) % map->count];
 }

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

@@ -120,7 +120,7 @@ static bool update_list(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
                         grpc_error* error) {
   bool sched_any = false;
   grpc_chttp2_write_cb* cb = *list;
-  *list = NULL;
+  *list = nullptr;
   *ctr += send_bytes;
   while (cb) {
     grpc_chttp2_write_cb* next = cb->next;
@@ -330,24 +330,25 @@ class DataSendContext {
     bool is_last_data_frame =
         (send_bytes == s_->compressed_data_buffer.length &&
          s_->flow_controlled_buffer.length == 0 &&
-         s_->fetching_send_message == NULL);
-    if (is_last_data_frame && s_->send_trailing_metadata != NULL &&
-        s_->stream_compression_ctx != NULL) {
-      if (!grpc_stream_compress(s_->stream_compression_ctx,
-                                &s_->flow_controlled_buffer,
-                                &s_->compressed_data_buffer, NULL, MAX_SIZE_T,
-                                GRPC_STREAM_COMPRESSION_FLUSH_FINISH)) {
+         s_->fetching_send_message == nullptr);
+    if (is_last_data_frame && s_->send_trailing_metadata != nullptr &&
+        s_->stream_compression_ctx != nullptr) {
+      if (!grpc_stream_compress(
+              s_->stream_compression_ctx, &s_->flow_controlled_buffer,
+              &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
+              GRPC_STREAM_COMPRESSION_FLUSH_FINISH)) {
         gpr_log(GPR_ERROR, "Stream compression failed.");
       }
       grpc_stream_compression_context_destroy(s_->stream_compression_ctx);
-      s_->stream_compression_ctx = NULL;
+      s_->stream_compression_ctx = nullptr;
       /* After finish, bytes in s->compressed_data_buffer may be
        * more than max_outgoing. Start another round of the current
        * while loop so that send_bytes and is_last_data_frame are
        * recalculated. */
       return;
     }
-    is_last_frame_ = is_last_data_frame && s_->send_trailing_metadata != NULL &&
+    is_last_frame_ = is_last_data_frame &&
+                     s_->send_trailing_metadata != nullptr &&
                      grpc_metadata_batch_is_empty(s_->send_trailing_metadata);
     grpc_chttp2_encode_data(s_->id, &s_->compressed_data_buffer, send_bytes,
                             is_last_frame_, &s_->stats.outgoing, &t_->outbuf);
@@ -358,14 +359,14 @@ class DataSendContext {
   }
 
   void CompressMoreBytes() {
-    if (s_->stream_compression_ctx == NULL) {
+    if (s_->stream_compression_ctx == nullptr) {
       s_->stream_compression_ctx =
           grpc_stream_compression_context_create(s_->stream_compression_method);
     }
     s_->uncompressed_data_size = s_->flow_controlled_buffer.length;
     if (!grpc_stream_compress(s_->stream_compression_ctx,
                               &s_->flow_controlled_buffer,
-                              &s_->compressed_data_buffer, NULL, MAX_SIZE_T,
+                              &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
                               GRPC_STREAM_COMPRESSION_FLUSH_SYNC)) {
       gpr_log(GPR_ERROR, "Stream compression failed.");
     }
@@ -397,7 +398,7 @@ class StreamWriteContext {
     GRPC_CHTTP2_IF_TRACING(
         gpr_log(GPR_DEBUG, "W:%p %s[%d] im-(sent,send)=(%d,%d) announce=%d", t_,
                 t_->is_client ? "CLIENT" : "SERVER", s->id,
-                s->sent_initial_metadata, s->send_initial_metadata != NULL,
+                s->sent_initial_metadata, s->send_initial_metadata != nullptr,
                 (int)(s->flow_control->local_window_delta() -
                       s->flow_control->announced_window_delta())));
   }
@@ -429,13 +430,13 @@ class StreamWriteContext {
                       [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
           &s_->stats.outgoing                                 // stats
       };
-      grpc_chttp2_encode_header(exec_ctx, &t_->hpack_compressor, NULL, 0,
+      grpc_chttp2_encode_header(exec_ctx, &t_->hpack_compressor, nullptr, 0,
                                 s_->send_initial_metadata, &hopt, &t_->outbuf);
       write_context_->ResetPingRecvClock();
       write_context_->IncInitialMetadataWrites();
     }
 
-    s_->send_initial_metadata = NULL;
+    s_->send_initial_metadata = nullptr;
     s_->sent_initial_metadata = true;
     write_context_->NoteScheduledResults();
     grpc_chttp2_complete_closure_step(
@@ -502,8 +503,8 @@ class StreamWriteContext {
   void FlushTrailingMetadata(grpc_exec_ctx* exec_ctx) {
     if (!s_->sent_initial_metadata) return;
 
-    if (s_->send_trailing_metadata == NULL) return;
-    if (s_->fetching_send_message != NULL) return;
+    if (s_->send_trailing_metadata == nullptr) return;
+    if (s_->fetching_send_message != nullptr) return;
     if (s_->flow_controlled_buffer.length != 0) return;
     if (s_->compressed_data_buffer.length != 0) return;
 
@@ -543,12 +544,12 @@ class StreamWriteContext {
         gpr_log(GPR_INFO, "not sending initial_metadata (Trailers-Only)"));
     // When sending Trailers-Only, we need to move the :status and
     // content-type headers to the trailers.
-    if (s_->send_initial_metadata->idx.named.status != NULL) {
+    if (s_->send_initial_metadata->idx.named.status != nullptr) {
       extra_headers_for_trailing_metadata_
           [num_extra_headers_for_trailing_metadata_++] =
               &s_->send_initial_metadata->idx.named.status->md;
     }
-    if (s_->send_initial_metadata->idx.named.content_type != NULL) {
+    if (s_->send_initial_metadata->idx.named.content_type != nullptr) {
       extra_headers_for_trailing_metadata_
           [num_extra_headers_for_trailing_metadata_++] =
               &s_->send_initial_metadata->idx.named.content_type->md;
@@ -556,7 +557,7 @@ class StreamWriteContext {
   }
 
   void SentLastFrame(grpc_exec_ctx* exec_ctx) {
-    s_->send_trailing_metadata = NULL;
+    s_->send_trailing_metadata = nullptr;
     s_->sent_trailing_metadata = true;
 
     if (!t_->is_client && !s_->read_closed) {

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

@@ -33,7 +33,7 @@ bidirectional_stream* bidirectional_stream_create(
     stream_engine* engine, void* annotation,
     bidirectional_stream_callback* callback) {
   GPR_ASSERT(0);
-  return NULL;
+  return nullptr;
 }
 
 int bidirectional_stream_destroy(bidirectional_stream* stream) {

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

@@ -273,7 +273,7 @@ static void null_and_maybe_free_read_buffer(stream_obj* s) {
       s->state.rs.read_buffer != s->state.rs.grpc_header_bytes) {
     gpr_free(s->state.rs.read_buffer);
   }
-  s->state.rs.read_buffer = NULL;
+  s->state.rs.read_buffer = nullptr;
 }
 
 static void maybe_flush_read(stream_obj* s) {
@@ -342,7 +342,7 @@ static void add_to_storage(struct stream_obj* s,
 static void remove_from_storage(struct stream_obj* s,
                                 struct op_and_state* oas) {
   struct op_and_state* curr;
-  if (s->storage.head == NULL || oas == NULL) {
+  if (s->storage.head == nullptr || oas == nullptr) {
     return;
   }
   if (s->storage.head == oas) {
@@ -352,7 +352,7 @@ static void remove_from_storage(struct stream_obj* s,
     CRONET_LOG(GPR_DEBUG, "Freed %p. Now %d in the queue", oas,
                s->storage.num_pending_ops);
   } else {
-    for (curr = s->storage.head; curr != NULL; curr = curr->next) {
+    for (curr = s->storage.head; curr != nullptr; curr = curr->next) {
       if (curr->next == oas) {
         curr->next = oas->next;
         s->storage.num_pending_ops--;
@@ -360,7 +360,7 @@ static void remove_from_storage(struct stream_obj* s,
                    s->storage.num_pending_ops);
         gpr_free(oas);
         break;
-      } else if (curr->next == NULL) {
+      } else if (curr->next == nullptr) {
         CRONET_LOG(GPR_ERROR, "Reached end of LL and did not find op to free");
       }
     }
@@ -375,7 +375,7 @@ static void remove_from_storage(struct stream_obj* s,
 */
 static void execute_from_storage(grpc_exec_ctx* exec_ctx, stream_obj* s) {
   gpr_mu_lock(&s->mu);
-  for (struct op_and_state* curr = s->storage.head; curr != NULL;) {
+  for (struct op_and_state* curr = s->storage.head; curr != nullptr;) {
     CRONET_LOG(GPR_DEBUG, "calling op at %p. done = %d", curr, curr->done);
     GPR_ASSERT(curr->done == 0);
     enum e_op_result result = execute_stream_op(exec_ctx, curr);
@@ -408,14 +408,14 @@ static void on_failed(bidirectional_stream* stream, int net_error) {
   gpr_mu_lock(&s->mu);
   bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_FAILED] = true;
-  s->cbs = NULL;
+  s->cbs = nullptr;
   if (s->header_array.headers) {
     gpr_free(s->header_array.headers);
-    s->header_array.headers = NULL;
+    s->header_array.headers = nullptr;
   }
   if (s->state.ws.write_buffer) {
     gpr_free(s->state.ws.write_buffer);
-    s->state.ws.write_buffer = NULL;
+    s->state.ws.write_buffer = nullptr;
   }
   null_and_maybe_free_read_buffer(s);
   gpr_mu_unlock(&s->mu);
@@ -435,14 +435,14 @@ static void on_canceled(bidirectional_stream* stream) {
   gpr_mu_lock(&s->mu);
   bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_CANCELED] = true;
-  s->cbs = NULL;
+  s->cbs = nullptr;
   if (s->header_array.headers) {
     gpr_free(s->header_array.headers);
-    s->header_array.headers = NULL;
+    s->header_array.headers = nullptr;
   }
   if (s->state.ws.write_buffer) {
     gpr_free(s->state.ws.write_buffer);
-    s->state.ws.write_buffer = NULL;
+    s->state.ws.write_buffer = nullptr;
   }
   null_and_maybe_free_read_buffer(s);
   gpr_mu_unlock(&s->mu);
@@ -462,7 +462,7 @@ static void on_succeeded(bidirectional_stream* stream) {
   gpr_mu_lock(&s->mu);
   bidirectional_stream_destroy(s->cbs);
   s->state.state_callback_received[OP_SUCCEEDED] = true;
-  s->cbs = NULL;
+  s->cbs = nullptr;
   null_and_maybe_free_read_buffer(s);
   gpr_mu_unlock(&s->mu);
   execute_from_storage(&exec_ctx, s);
@@ -484,7 +484,7 @@ static void on_stream_ready(bidirectional_stream* stream) {
   /* Free the memory allocated for headers */
   if (s->header_array.headers) {
     gpr_free(s->header_array.headers);
-    s->header_array.headers = NULL;
+    s->header_array.headers = nullptr;
   }
   /* Send the initial metadata on wire if there is no SEND_MESSAGE or
    * SEND_TRAILING_METADATA ops pending */
@@ -566,7 +566,7 @@ static void on_write_completed(bidirectional_stream* stream, const char* data) {
   gpr_mu_lock(&s->mu);
   if (s->state.ws.write_buffer) {
     gpr_free(s->state.ws.write_buffer);
-    s->state.ws.write_buffer = NULL;
+    s->state.ws.write_buffer = nullptr;
   }
   s->state.state_callback_received[OP_SEND_MESSAGE] = true;
   gpr_mu_unlock(&s->mu);
@@ -713,7 +713,7 @@ static void convert_metadata_to_cronet_headers(
   grpc_linked_mdelem* curr = head;
   /* Walk the linked list and get number of header fields */
   size_t num_headers_available = 0;
-  while (curr != NULL) {
+  while (curr != nullptr) {
     curr = curr->next;
     num_headers_available++;
   }
@@ -765,7 +765,7 @@ static void convert_metadata_to_cronet_headers(
     headers[num_headers].key = key;
     headers[num_headers].value = value;
     num_headers++;
-    if (curr == NULL) {
+    if (curr == nullptr) {
       break;
     }
   }
@@ -785,7 +785,7 @@ static void parse_grpc_header(const uint8_t* data, int* length,
 }
 
 static bool header_has_authority(grpc_linked_mdelem* head) {
-  while (head != NULL) {
+  while (head != nullptr) {
     if (grpc_slice_eq(GRPC_MDKEY(head->md), GRPC_MDSTR_AUTHORITY)) {
       return true;
     }
@@ -993,7 +993,7 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx* exec_ctx,
     CRONET_LOG(GPR_DEBUG, "running: %p OP_SEND_INITIAL_METADATA", oas);
     /* Start new cronet stream. It is destroyed in on_succeeded, on_canceled,
      * on_failed */
-    GPR_ASSERT(s->cbs == NULL);
+    GPR_ASSERT(s->cbs == nullptr);
     GPR_ASSERT(!stream_state->state_op_done[OP_SEND_INITIAL_METADATA]);
     s->cbs =
         bidirectional_stream_create(t->engine, s->curr_gs, &cronet_callbacks);
@@ -1002,9 +1002,9 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx* exec_ctx,
       bidirectional_stream_disable_auto_flush(s->cbs, true);
       bidirectional_stream_delay_request_headers_until_flush(s->cbs, true);
     }
-    char* url = NULL;
+    char* url = nullptr;
     const char* method = "POST";
-    s->header_array.headers = NULL;
+    s->header_array.headers = nullptr;
     convert_metadata_to_cronet_headers(stream_op->payload->send_initial_metadata
                                            .send_initial_metadata->list.head,
                                        t->host, &url, &s->header_array.headers,
@@ -1042,7 +1042,7 @@ static enum e_op_result execute_stream_op(grpc_exec_ctx* exec_ctx,
       if (1 != grpc_byte_stream_next(
                    exec_ctx, stream_op->payload->send_message.send_message,
                    stream_op->payload->send_message.send_message->length,
-                   NULL)) {
+                   nullptr)) {
         /* Should never reach here */
         GPR_ASSERT(false);
       }
@@ -1358,10 +1358,10 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   s->refcount = refcount;
   GRPC_CRONET_STREAM_REF(s, "cronet transport");
   memset(&s->storage, 0, sizeof(s->storage));
-  s->storage.head = NULL;
+  s->storage.head = nullptr;
   memset(&s->state, 0, sizeof(s->state));
-  s->curr_op = NULL;
-  s->cbs = NULL;
+  s->curr_op = nullptr;
+  s->cbs = nullptr;
   memset(&s->header_array, 0, sizeof(s->header_array));
   memset(&s->state.rs, 0, sizeof(s->state.rs));
   memset(&s->state.ws, 0, sizeof(s->state.ws));
@@ -1369,7 +1369,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   memset(s->state.state_callback_received, 0,
          sizeof(s->state.state_callback_received));
   s->state.fail_state = s->state.flush_read = false;
-  s->state.cancel_error = NULL;
+  s->state.cancel_error = nullptr;
   s->state.flush_cronet_when_ready = s->state.pending_write_for_trailer = false;
   s->state.pending_send_message = false;
   s->state.pending_recv_trailing_metadata = false;
@@ -1432,7 +1432,7 @@ static void destroy_transport(grpc_exec_ctx* exec_ctx, grpc_transport* gt) {}
 
 static grpc_endpoint* get_endpoint(grpc_exec_ctx* exec_ctx,
                                    grpc_transport* gt) {
-  return NULL;
+  return nullptr;
 }
 
 static void perform_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
@@ -1491,5 +1491,5 @@ error:
     gpr_free(ct);
   }
 
-  return NULL;
+  return nullptr;
 }

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

@@ -184,7 +184,7 @@ static void really_destroy_stream(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
 
 static void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                          bool is_initial) {
-  for (grpc_linked_mdelem* md = md_batch->list.head; md != NULL;
+  for (grpc_linked_mdelem* md = md_batch->list.head; md != nullptr;
        md = md->next) {
     char* key = grpc_slice_to_c_string(GRPC_MDKEY(md->md));
     char* value = grpc_slice_to_c_string(GRPC_MDVALUE(md->md));
@@ -200,18 +200,18 @@ static grpc_error* fill_in_metadata(grpc_exec_ctx* exec_ctx, inproc_stream* s,
                                     uint32_t flags, grpc_metadata_batch* out_md,
                                     uint32_t* outflags, bool* markfilled) {
   if (GRPC_TRACER_ON(grpc_inproc_trace)) {
-    log_metadata(metadata, s->t->is_client, outflags != NULL);
+    log_metadata(metadata, s->t->is_client, outflags != nullptr);
   }
 
-  if (outflags != NULL) {
+  if (outflags != nullptr) {
     *outflags = flags;
   }
-  if (markfilled != NULL) {
+  if (markfilled != nullptr) {
     *markfilled = true;
   }
   grpc_error* error = GRPC_ERROR_NONE;
   for (grpc_linked_mdelem* elem = metadata->list.head;
-       (elem != NULL) && (error == GRPC_ERROR_NONE); elem = elem->next) {
+       (elem != nullptr) && (error == GRPC_ERROR_NONE); elem = elem->next) {
     grpc_linked_mdelem* nelem =
         (grpc_linked_mdelem*)gpr_arena_alloc(s->arena, sizeof(*nelem));
     nelem->md = grpc_mdelem_from_slices(
@@ -250,7 +250,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   GRPC_CLOSURE_INIT(&s->op_closure, op_state_machine, s,
                     grpc_schedule_on_exec_ctx);
   s->t = t;
-  s->closure_at_destroy = NULL;
+  s->closure_at_destroy = nullptr;
   s->other_side_closed = false;
 
   s->initial_md_sent = s->trailing_md_sent = s->initial_md_recvd =
@@ -264,7 +264,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   s->deadline = GRPC_MILLIS_INF_FUTURE;
   s->write_buffer_deadline = GRPC_MILLIS_INF_FUTURE;
 
-  s->stream_list_prev = NULL;
+  s->stream_list_prev = nullptr;
   gpr_mu_lock(&t->mu->mu);
   s->listed = true;
   ref_stream(s, "inproc_init_stream:list");
@@ -279,7 +279,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     ref_transport(t);
     inproc_transport* st = t->other_side;
     ref_transport(st);
-    s->other_side = NULL;  // will get filled in soon
+    s->other_side = nullptr;  // will get filled in soon
     // Pass the client-side stream address to the server-side for a ref
     ref_stream(s, "inproc_init_stream:clt");  // ref it now on behalf of server
                                               // side to avoid destruction
@@ -311,7 +311,7 @@ static int init_stream(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     }
     if (cs->write_buffer_trailing_md_filled) {
       fill_in_metadata(exec_ctx, s, &cs->write_buffer_trailing_md, 0,
-                       &s->to_read_trailing_md, NULL,
+                       &s->to_read_trailing_md, nullptr,
                        &s->to_read_trailing_md_filled);
       grpc_metadata_batch_clear(exec_ctx, &cs->write_buffer_trailing_md);
       cs->write_buffer_trailing_md_filled = false;
@@ -335,12 +335,12 @@ static void close_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
     if (s->listed) {
       inproc_stream* p = s->stream_list_prev;
       inproc_stream* n = s->stream_list_next;
-      if (p != NULL) {
+      if (p != nullptr) {
         p->stream_list_next = n;
       } else {
         s->t->stream_list = n;
       }
-      if (n != NULL) {
+      if (n != nullptr) {
         n->stream_list_prev = p;
       }
       s->listed = false;
@@ -354,14 +354,14 @@ static void close_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s) {
 // This function means that we are done talking/listening to the other side
 static void close_other_side_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
                                     const char* reason) {
-  if (s->other_side != NULL) {
+  if (s->other_side != nullptr) {
     // First release the metadata that came from the other side's arena
     grpc_metadata_batch_destroy(exec_ctx, &s->to_read_initial_md);
     grpc_metadata_batch_destroy(exec_ctx, &s->to_read_trailing_md);
 
     unref_stream(exec_ctx, s->other_side, reason);
     s->other_side_closed = true;
-    s->other_side = NULL;
+    s->other_side = nullptr;
   } else if (!s->other_side_closed) {
     s->write_buffer_other_side_closed = true;
   }
@@ -410,14 +410,15 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     grpc_metadata_batch_init(&fake_md);
 
     inproc_stream* other = s->other_side;
-    grpc_metadata_batch* dest = (other == NULL) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
-    bool* destfilled = (other == NULL) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
-    fill_in_metadata(exec_ctx, s, &fake_md, 0, dest, NULL, destfilled);
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
+    bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
+                                          : &other->to_read_trailing_md_filled;
+    fill_in_metadata(exec_ctx, s, &fake_md, 0, dest, nullptr, destfilled);
     grpc_metadata_batch_destroy(exec_ctx, &fake_md);
 
-    if (other != NULL) {
+    if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
         other->cancel_other_error = GRPC_ERROR_REF(error);
       }
@@ -451,7 +452,7 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          NULL);
+          nullptr);
       grpc_metadata_batch_destroy(exec_ctx, &fake_md);
       err = GRPC_ERROR_NONE;
     } else {
@@ -469,7 +470,7 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     complete_if_batch_end_locked(
         exec_ctx, s, error, s->recv_initial_md_op,
         "fail_helper scheduling recv-initial-metadata-on-complete");
-    s->recv_initial_md_op = NULL;
+    s->recv_initial_md_op = nullptr;
   }
   if (s->recv_message_op) {
     INPROC_LOG(GPR_DEBUG, "fail_helper %p scheduling message-ready %p", s,
@@ -480,19 +481,19 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     complete_if_batch_end_locked(
         exec_ctx, s, error, s->recv_message_op,
         "fail_helper scheduling recv-message-on-complete");
-    s->recv_message_op = NULL;
+    s->recv_message_op = nullptr;
   }
   if (s->send_message_op) {
     complete_if_batch_end_locked(
         exec_ctx, s, error, s->send_message_op,
         "fail_helper scheduling send-message-on-complete");
-    s->send_message_op = NULL;
+    s->send_message_op = nullptr;
   }
   if (s->send_trailing_md_op) {
     complete_if_batch_end_locked(
         exec_ctx, s, error, s->send_trailing_md_op,
         "fail_helper scheduling send-trailng-md-on-complete");
-    s->send_trailing_md_op = NULL;
+    s->send_trailing_md_op = nullptr;
   }
   if (s->recv_trailing_md_op) {
     INPROC_LOG(GPR_DEBUG,
@@ -501,7 +502,7 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     complete_if_batch_end_locked(
         exec_ctx, s, error, s->recv_trailing_md_op,
         "fail_helper scheduling recv-trailing-metadata-on-complete");
-    s->recv_trailing_md_op = NULL;
+    s->recv_trailing_md_op = nullptr;
   }
   close_other_side_locked(exec_ctx, s, "fail_helper:other_side");
   close_stream_locked(exec_ctx, s);
@@ -554,8 +555,8 @@ static void message_transfer_locked(grpc_exec_ctx* exec_ctx,
       exec_ctx, receiver, GRPC_ERROR_NONE, receiver->recv_message_op,
       "message_transfer scheduling receiver on_complete");
 
-  receiver->recv_message_op = NULL;
-  sender->send_message_op = NULL;
+  receiver->recv_message_op = nullptr;
+  sender->send_message_op = nullptr;
 }
 
 static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
@@ -601,7 +602,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       complete_if_batch_end_locked(
           exec_ctx, s, GRPC_ERROR_NONE, s->send_message_op,
           "op_state_machine scheduling send-message-on-complete");
-      s->send_message_op = NULL;
+      s->send_message_op = nullptr;
     }
   }
   // Pause a send trailing metadata if there is still an outstanding
@@ -612,10 +613,11 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       (!s->send_message_op ||
        (s->t->is_client &&
         (s->trailing_md_recvd || s->to_read_trailing_md_filled)))) {
-    grpc_metadata_batch* dest = (other == NULL) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
-    bool* destfilled = (other == NULL) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
+    bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
+                                          : &other->to_read_trailing_md_filled;
     if (*destfilled || s->trailing_md_sent) {
       // The buffer is already in use; that's an error!
       INPROC_LOG(GPR_DEBUG, "Extra trailing metadata %p", s);
@@ -627,7 +629,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
         fill_in_metadata(exec_ctx, s,
                          s->send_trailing_md_op->payload->send_trailing_metadata
                              .send_trailing_metadata,
-                         0, dest, NULL, destfilled);
+                         0, dest, nullptr, destfilled);
       }
       s->trailing_md_sent = true;
       if (!s->t->is_client && s->trailing_md_recvd && s->recv_trailing_md_op) {
@@ -635,7 +637,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
                    "op_state_machine %p scheduling trailing-md-on-complete", s);
         GRPC_CLOSURE_SCHED(exec_ctx, s->recv_trailing_md_op->on_complete,
                            GRPC_ERROR_NONE);
-        s->recv_trailing_md_op = NULL;
+        s->recv_trailing_md_op = nullptr;
         needs_close = true;
       }
     }
@@ -643,7 +645,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
     complete_if_batch_end_locked(
         exec_ctx, s, GRPC_ERROR_NONE, s->send_trailing_md_op,
         "op_state_machine scheduling send-trailing-metadata-on-complete");
-    s->send_trailing_md_op = NULL;
+    s->send_trailing_md_op = nullptr;
   }
   if (s->recv_initial_md_op) {
     if (s->initial_md_recvd) {
@@ -665,7 +667,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          NULL);
+          nullptr);
       s->recv_initial_md_op->payload->recv_initial_metadata
           .recv_initial_metadata->deadline = s->deadline;
       grpc_metadata_batch_clear(exec_ctx, &s->to_read_initial_md);
@@ -680,7 +682,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       complete_if_batch_end_locked(
           exec_ctx, s, new_err, s->recv_initial_md_op,
           "op_state_machine scheduling recv-initial-metadata-on-complete");
-      s->recv_initial_md_op = NULL;
+      s->recv_initial_md_op = nullptr;
 
       if (new_err != GRPC_ERROR_NONE) {
         INPROC_LOG(GPR_DEBUG,
@@ -713,7 +715,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       fail_helper_locked(exec_ctx, s, GRPC_ERROR_REF(new_err));
       goto done;
     }
-    if (s->recv_message_op != NULL) {
+    if (s->recv_message_op != nullptr) {
       // This message needs to be wrapped up because it will never be
       // satisfied
       INPROC_LOG(GPR_DEBUG, "op_state_machine %p scheduling message-ready", s);
@@ -724,7 +726,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       complete_if_batch_end_locked(
           exec_ctx, s, new_err, s->recv_message_op,
           "op_state_machine scheduling recv-message-on-complete");
-      s->recv_message_op = NULL;
+      s->recv_message_op = nullptr;
     }
     if ((s->trailing_md_sent || s->t->is_client) && s->send_message_op) {
       // Nothing further will try to receive from this stream, so finish off
@@ -732,16 +734,16 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       complete_if_batch_end_locked(
           exec_ctx, s, new_err, s->send_message_op,
           "op_state_machine scheduling send-message-on-complete");
-      s->send_message_op = NULL;
+      s->send_message_op = nullptr;
     }
-    if (s->recv_trailing_md_op != NULL) {
+    if (s->recv_trailing_md_op != nullptr) {
       // We wanted trailing metadata and we got it
       s->trailing_md_recvd = true;
       new_err =
           fill_in_metadata(exec_ctx, s, &s->to_read_trailing_md, 0,
                            s->recv_trailing_md_op->payload
                                ->recv_trailing_metadata.recv_trailing_metadata,
-                           NULL, NULL);
+                           nullptr, nullptr);
       grpc_metadata_batch_clear(exec_ctx, &s->to_read_trailing_md);
       s->to_read_trailing_md_filled = false;
 
@@ -756,7 +758,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
                    s, new_err);
         GRPC_CLOSURE_SCHED(exec_ctx, s->recv_trailing_md_op->on_complete,
                            GRPC_ERROR_REF(new_err));
-        s->recv_trailing_md_op = NULL;
+        s->recv_trailing_md_op = nullptr;
         needs_close = true;
       } else {
         INPROC_LOG(GPR_DEBUG,
@@ -780,7 +782,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
     complete_if_batch_end_locked(
         exec_ctx, s, new_err, s->recv_message_op,
         "op_state_machine scheduling recv-message-on-complete");
-    s->recv_message_op = NULL;
+    s->recv_message_op = nullptr;
   }
   if (s->trailing_md_recvd && (s->trailing_md_sent || s->t->is_client) &&
       s->send_message_op) {
@@ -789,7 +791,7 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
     complete_if_batch_end_locked(
         exec_ctx, s, new_err, s->send_message_op,
         "op_state_machine scheduling send-message-on-complete");
-    s->send_message_op = NULL;
+    s->send_message_op = nullptr;
   }
   if (s->send_message_op || s->send_trailing_md_op || s->recv_initial_md_op ||
       s->recv_message_op || s->recv_trailing_md_op) {
@@ -827,14 +829,15 @@ static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     grpc_metadata_batch_init(&cancel_md);
 
     inproc_stream* other = s->other_side;
-    grpc_metadata_batch* dest = (other == NULL) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
-    bool* destfilled = (other == NULL) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
-    fill_in_metadata(exec_ctx, s, &cancel_md, 0, dest, NULL, destfilled);
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
+    bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
+                                          : &other->to_read_trailing_md_filled;
+    fill_in_metadata(exec_ctx, s, &cancel_md, 0, dest, nullptr, destfilled);
     grpc_metadata_batch_destroy(exec_ctx, &cancel_md);
 
-    if (other != NULL) {
+    if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
         other->cancel_other_error = GRPC_ERROR_REF(s->cancel_self_error);
       }
@@ -851,7 +854,7 @@ static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
       complete_if_batch_end_locked(
           exec_ctx, s, s->cancel_self_error, s->recv_trailing_md_op,
           "cancel_stream scheduling trailing-md-on-complete");
-      s->recv_trailing_md_op = NULL;
+      s->recv_trailing_md_op = nullptr;
     }
   }
 
@@ -882,7 +885,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
   }
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_closure* on_complete = op->on_complete;
-  if (on_complete == NULL) {
+  if (on_complete == nullptr) {
     on_complete = &do_nothing_closure;
   }
 
@@ -914,12 +917,14 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Endpoint already shutdown");
     }
     if (error == GRPC_ERROR_NONE && op->send_initial_metadata) {
-      grpc_metadata_batch* dest = (other == NULL) ? &s->write_buffer_initial_md
-                                                  : &other->to_read_initial_md;
-      uint32_t* destflags = (other == NULL) ? &s->write_buffer_initial_md_flags
-                                            : &other->to_read_initial_md_flags;
-      bool* destfilled = (other == NULL) ? &s->write_buffer_initial_md_filled
-                                         : &other->to_read_initial_md_filled;
+      grpc_metadata_batch* dest = (other == nullptr)
+                                      ? &s->write_buffer_initial_md
+                                      : &other->to_read_initial_md;
+      uint32_t* destflags = (other == nullptr)
+                                ? &s->write_buffer_initial_md_flags
+                                : &other->to_read_initial_md_flags;
+      bool* destfilled = (other == nullptr) ? &s->write_buffer_initial_md_filled
+                                            : &other->to_read_initial_md_filled;
       if (*destfilled || s->initial_md_sent) {
         // The buffer is already in use; that's an error!
         INPROC_LOG(GPR_DEBUG, "Extra initial metadata %p", s);
@@ -934,7 +939,7 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
         }
         if (s->t->is_client) {
           grpc_millis* dl =
-              (other == NULL) ? &s->write_buffer_deadline : &other->deadline;
+              (other == nullptr) ? &s->write_buffer_deadline : &other->deadline;
           *dl = GPR_MIN(*dl, op->payload->send_initial_metadata
                                  .send_initial_metadata->deadline);
           s->initial_md_sent = true;
@@ -973,11 +978,11 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
     // 5. There is trailing metadata, even if nothing specifically wants
     //    that because that can shut down the receive message as well
     if ((op->send_message && other &&
-         ((other->recv_message_op != NULL) ||
-          (other->recv_trailing_md_op != NULL))) ||
+         ((other->recv_message_op != nullptr) ||
+          (other->recv_trailing_md_op != nullptr))) ||
         (op->send_trailing_metadata && !op->send_message) ||
         (op->recv_initial_metadata && s->to_read_initial_md_filled) ||
-        (op->recv_message && other && (other->send_message_op != NULL)) ||
+        (op->recv_message && other && (other->send_message_op != nullptr)) ||
         (s->to_read_trailing_md_filled || s->trailing_md_recvd)) {
       if (!s->op_closure_scheduled) {
         GRPC_CLOSURE_SCHED(exec_ctx, &s->op_closure, GRPC_ERROR_NONE);
@@ -1031,7 +1036,7 @@ static void close_transport_locked(grpc_exec_ctx* exec_ctx,
   if (!t->is_closed) {
     t->is_closed = true;
     /* Also end all streams on this transport */
-    while (t->stream_list != NULL) {
+    while (t->stream_list != nullptr) {
       // cancel_stream_locked also adjusts stream list
       cancel_stream_locked(
           exec_ctx, t->stream_list,
@@ -1110,7 +1115,7 @@ static void set_pollset_set(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
 }
 
 static grpc_endpoint* get_endpoint(grpc_exec_ctx* exec_ctx, grpc_transport* t) {
-  return NULL;
+  return nullptr;
 }
 
 /*******************************************************************************
@@ -1120,9 +1125,9 @@ static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
 
 void grpc_inproc_transport_init(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GRPC_CLOSURE_INIT(&do_nothing_closure, do_nothing, NULL,
+  GRPC_CLOSURE_INIT(&do_nothing_closure, do_nothing, nullptr,
                     grpc_schedule_on_exec_ctx);
-  g_empty_slice = grpc_slice_from_static_buffer(NULL, 0);
+  g_empty_slice = grpc_slice_from_static_buffer(nullptr, 0);
 
   grpc_slice key_tmp = grpc_slice_from_static_string(":path");
   g_fake_path_key = grpc_slice_intern(key_tmp);
@@ -1173,8 +1178,8 @@ static void inproc_transports_create(grpc_exec_ctx* exec_ctx,
                                "inproc_client");
   st->other_side = ct;
   ct->other_side = st;
-  st->stream_list = NULL;
-  ct->stream_list = NULL;
+  st->stream_list = nullptr;
+  ct->stream_list = nullptr;
   *server_transport = (grpc_transport*)st;
   *client_transport = (grpc_transport*)ct;
 }
@@ -1203,7 +1208,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   inproc_transports_create(&exec_ctx, &server_transport, server_args,
                            &client_transport, client_args);
 
-  grpc_server_setup_transport(&exec_ctx, server, server_transport, NULL,
+  grpc_server_setup_transport(&exec_ctx, server, server_transport, nullptr,
                               server_args);
   grpc_channel* channel =
       grpc_channel_create(&exec_ctx, "inproc", client_args,

src/core/lib/channel/channel_args.cc

@@ -54,7 +54,7 @@ static grpc_arg copy_arg(const grpc_arg* src) {
 grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
                                                   const grpc_arg* to_add,
                                                   size_t num_to_add) {
-  return grpc_channel_args_copy_and_add_and_remove(src, NULL, 0, to_add,
+  return grpc_channel_args_copy_and_add_and_remove(src, nullptr, 0, to_add,
                                                    num_to_add);
 }
 
@@ -62,7 +62,7 @@ grpc_channel_args* grpc_channel_args_copy_and_remove(
     const grpc_channel_args* src, const char** to_remove,
     size_t num_to_remove) {
   return grpc_channel_args_copy_and_add_and_remove(src, to_remove,
-                                                   num_to_remove, NULL, 0);
+                                                   num_to_remove, nullptr, 0);
 }
 
 static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
@@ -78,7 +78,7 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
     const grpc_arg* to_add, size_t num_to_add) {
   // Figure out how many args we'll be copying.
   size_t num_args_to_copy = 0;
-  if (src != NULL) {
+  if (src != nullptr) {
     for (size_t i = 0; i < src->num_args; ++i) {
       if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
         ++num_args_to_copy;
@@ -90,13 +90,13 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
       (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
   dst->num_args = num_args_to_copy + num_to_add;
   if (dst->num_args == 0) {
-    dst->args = NULL;
+    dst->args = nullptr;
     return dst;
   }
   dst->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
   // Copy args from src that are not being removed.
   size_t dst_idx = 0;
-  if (src != NULL) {
+  if (src != nullptr) {
     for (size_t i = 0; i < src->num_args; ++i) {
       if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
         dst->args[dst_idx++] = copy_arg(&src->args[i]);
@@ -112,7 +112,7 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
 }
 
 grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
-  return grpc_channel_args_copy_and_add(src, NULL, 0);
+  return grpc_channel_args_copy_and_add(src, nullptr, 0);
 }
 
 grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
@@ -124,12 +124,12 @@ grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
   size_t uniques_idx = a->num_args;
   for (size_t i = 0; i < b->num_args; ++i) {
     const char* b_key = b->args[i].key;
-    if (grpc_channel_args_find(a, b_key) == NULL) {  // not found
+    if (grpc_channel_args_find(a, b_key) == nullptr) {  // not found
       uniques[uniques_idx++] = b->args[i];
     }
   }
   grpc_channel_args* result =
-      grpc_channel_args_copy_and_add(NULL, uniques, uniques_idx);
+      grpc_channel_args_copy_and_add(nullptr, uniques, uniques_idx);
   gpr_free(uniques);
   return result;
 }
@@ -212,7 +212,7 @@ void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a) {
 grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
     const grpc_channel_args* a) {
   size_t i;
-  if (a == NULL) return GRPC_COMPRESS_NONE;
+  if (a == nullptr) return GRPC_COMPRESS_NONE;
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
@@ -226,7 +226,7 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
 grpc_stream_compression_algorithm
 grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a) {
   size_t i;
-  if (a == NULL) return GRPC_STREAM_COMPRESS_NONE;
+  if (a == nullptr) return GRPC_STREAM_COMPRESS_NONE;
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
@@ -263,7 +263,7 @@ grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
  * 0. */
 static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
                                                     int** states_arg) {
-  if (a != NULL) {
+  if (a != nullptr) {
     size_t i;
     for (i = 0; i < a->num_args; ++i) {
       if (a->args[i].type == GRPC_ARG_INTEGER &&
@@ -283,7 +283,7 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
  * 0. */
 static int find_stream_compression_algorithm_states_bitset(
     const grpc_channel_args* a, int** states_arg) {
-  if (a != NULL) {
+  if (a != nullptr) {
     size_t i;
     for (i = 0; i < a->num_args; ++i) {
       if (a->args[i].type == GRPC_ARG_INTEGER &&
@@ -301,14 +301,14 @@ static int find_stream_compression_algorithm_states_bitset(
 grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
     grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
     grpc_compression_algorithm algorithm, int state) {
-  int* states_arg = NULL;
+  int* states_arg = nullptr;
   grpc_channel_args* result = *a;
   const int states_arg_found =
       find_compression_algorithm_states_bitset(*a, &states_arg);
 
   if (grpc_channel_args_get_compression_algorithm(*a) == algorithm &&
       state == 0) {
-    const char* algo_name = NULL;
+    const char* algo_name = nullptr;
     GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name) != 0);
     gpr_log(GPR_ERROR,
             "Tried to disable default compression algorithm '%s'. The "
@@ -342,14 +342,14 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
 grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
     grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
     grpc_stream_compression_algorithm algorithm, int state) {
-  int* states_arg = NULL;
+  int* states_arg = nullptr;
   grpc_channel_args* result = *a;
   const int states_arg_found =
       find_stream_compression_algorithm_states_bitset(*a, &states_arg);
 
   if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
       state == 0) {
-    const char* algo_name = NULL;
+    const char* algo_name = nullptr;
     GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
                0);
     gpr_log(GPR_ERROR,
@@ -421,19 +421,19 @@ int grpc_channel_args_compare(const grpc_channel_args* a,
 
 const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
                                        const char* name) {
-  if (args != NULL) {
+  if (args != nullptr) {
     for (size_t i = 0; i < args->num_args; ++i) {
       if (strcmp(args->args[i].key, name) == 0) {
         return &args->args[i];
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 int grpc_channel_arg_get_integer(const grpc_arg* arg,
                                  const grpc_integer_options options) {
-  if (arg == NULL) return options.default_value;
+  if (arg == nullptr) return options.default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
     return options.default_value;
@@ -452,7 +452,7 @@ int grpc_channel_arg_get_integer(const grpc_arg* arg,
 }
 
 bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
-  if (arg == NULL) return default_value;
+  if (arg == nullptr) return default_value;
   if (arg->type != GRPC_ARG_INTEGER) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
     return default_value;

src/core/lib/channel/channel_stack.cc

@@ -225,7 +225,7 @@ void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
   for (i = 0; i < count; i++) {
     elems[i].filter->destroy_call_elem(
         exec_ctx, &elems[i], final_info,
-        i == count - 1 ? then_schedule_closure : NULL);
+        i == count - 1 ? then_schedule_closure : nullptr);
   }
 }
 

src/core/lib/channel/channel_stack_builder.cc

@@ -54,8 +54,8 @@ grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
   grpc_channel_stack_builder* b =
       (grpc_channel_stack_builder*)gpr_zalloc(sizeof(*b));
 
-  b->begin.filter = NULL;
-  b->end.filter = NULL;
+  b->begin.filter = nullptr;
+  b->end.filter = nullptr;
   b->begin.next = &b->end;
   b->begin.prev = &b->end;
   b->end.next = &b->begin;
@@ -108,7 +108,7 @@ bool grpc_channel_stack_builder_iterator_is_end(
 
 const char* grpc_channel_stack_builder_iterator_filter_name(
     grpc_channel_stack_builder_iterator* iterator) {
-  if (iterator->node->filter == NULL) return NULL;
+  if (iterator->node->filter == nullptr) return nullptr;
   return iterator->node->filter->name;
 }
 
@@ -128,7 +128,7 @@ bool grpc_channel_stack_builder_move_prev(
 
 grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
     grpc_channel_stack_builder* builder, const char* filter_name) {
-  GPR_ASSERT(filter_name != NULL);
+  GPR_ASSERT(filter_name != nullptr);
   grpc_channel_stack_builder_iterator* it =
       grpc_channel_stack_builder_create_iterator_at_first(builder);
   while (grpc_channel_stack_builder_move_next(it)) {
@@ -145,14 +145,14 @@ bool grpc_channel_stack_builder_move_prev(
 
 void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
                                          const char* name) {
-  GPR_ASSERT(builder->name == NULL);
+  GPR_ASSERT(builder->name == nullptr);
   builder->name = name;
 }
 
 void grpc_channel_stack_builder_set_channel_arguments(
     grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
     const grpc_channel_args* args) {
-  if (builder->args != NULL) {
+  if (builder->args != nullptr) {
     grpc_channel_args_destroy(exec_ctx, builder->args);
   }
   builder->args = grpc_channel_args_copy(args);
@@ -160,7 +160,7 @@ void grpc_channel_stack_builder_set_channel_arguments(
 
 void grpc_channel_stack_builder_set_transport(
     grpc_channel_stack_builder* builder, grpc_transport* transport) {
-  GPR_ASSERT(builder->transport == NULL);
+  GPR_ASSERT(builder->transport == nullptr);
   builder->transport = transport;
 }
 
@@ -249,7 +249,7 @@ void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
     gpr_free(p);
     p = next;
   }
-  if (builder->args != NULL) {
+  if (builder->args != nullptr) {
     grpc_channel_args_destroy(exec_ctx, builder->args);
   }
   gpr_free(builder->target);
@@ -285,19 +285,19 @@ grpc_error* grpc_channel_stack_builder_finish(
   // and initialize it
   grpc_error* error = grpc_channel_stack_init(
       exec_ctx, initial_refs, destroy,
-      destroy_arg == NULL ? *result : destroy_arg, filters, num_filters,
+      destroy_arg == nullptr ? *result : destroy_arg, filters, num_filters,
       builder->args, builder->transport, builder->name, channel_stack);
 
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_stack_destroy(exec_ctx, channel_stack);
     gpr_free(*result);
-    *result = NULL;
+    *result = nullptr;
   } else {
     // run post-initialization functions
     i = 0;
     for (filter_node* p = builder->begin.next; p != &builder->end;
          p = p->next) {
-      if (p->init != NULL) {
+      if (p->init != nullptr) {
         p->init(channel_stack, grpc_channel_stack_element(channel_stack, i),
                 p->init_arg);
       }

src/core/lib/channel/connected_channel.cc

@@ -85,7 +85,7 @@ static callback_state* get_state_for_batch(
   if (batch->recv_initial_metadata) return &calld->on_complete[3];
   if (batch->recv_message) return &calld->on_complete[4];
   if (batch->recv_trailing_metadata) return &calld->on_complete[5];
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
 /* We perform a small hack to locate transport data alongside the connected
@@ -181,7 +181,7 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
                                      grpc_channel_element_args* args) {
   channel_data* cd = (channel_data*)elem->channel_data;
   GPR_ASSERT(args->is_last);
-  cd->transport = NULL;
+  cd->transport = nullptr;
   return GRPC_ERROR_NONE;
 }
 
@@ -217,7 +217,7 @@ static void bind_transport(grpc_channel_stack* channel_stack,
                            grpc_channel_element* elem, void* t) {
   channel_data* cd = (channel_data*)elem->channel_data;
   GPR_ASSERT(elem->filter == &grpc_connected_filter);
-  GPR_ASSERT(cd->transport == NULL);
+  GPR_ASSERT(cd->transport == nullptr);
   cd->transport = (grpc_transport*)t;
 
   /* HACK(ctiller): increase call stack size for the channel to make space
@@ -233,9 +233,9 @@ static void bind_transport(grpc_channel_stack* channel_stack,
 bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
                                grpc_channel_stack_builder* builder,
                                void* arg_must_be_null) {
-  GPR_ASSERT(arg_must_be_null == NULL);
+  GPR_ASSERT(arg_must_be_null == nullptr);
   grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
-  GPR_ASSERT(t != NULL);
+  GPR_ASSERT(t != nullptr);
   return grpc_channel_stack_builder_append_filter(
       builder, &grpc_connected_filter, bind_transport, t);
 }

src/core/lib/channel/handshaker.cc

@@ -93,8 +93,8 @@ grpc_handshake_manager* grpc_handshake_manager_create() {
 
 void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
                                              grpc_handshake_manager* mgr) {
-  GPR_ASSERT(mgr->prev == NULL);
-  GPR_ASSERT(mgr->next == NULL);
+  GPR_ASSERT(mgr->prev == nullptr);
+  GPR_ASSERT(mgr->next == nullptr);
   mgr->next = *head;
   if (*head) {
     (*head)->prev = mgr;
@@ -104,10 +104,10 @@ void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
 
 void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
                                                 grpc_handshake_manager* mgr) {
-  if (mgr->next != NULL) {
+  if (mgr->next != nullptr) {
     mgr->next->prev = mgr->prev;
   }
-  if (mgr->prev != NULL) {
+  if (mgr->prev != nullptr) {
     mgr->prev->next = mgr->next;
   } else {
     GPR_ASSERT(*head == mgr);
@@ -117,7 +117,7 @@ void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
 
 void grpc_handshake_manager_pending_list_shutdown_all(
     grpc_exec_ctx* exec_ctx, grpc_handshake_manager* head, grpc_error* why) {
-  while (head != NULL) {
+  while (head != nullptr) {
     grpc_handshake_manager_shutdown(exec_ctx, head, GRPC_ERROR_REF(why));
     head = head->next;
   }

src/core/lib/channel/handshaker_factory.cc

@@ -23,8 +23,8 @@
 void grpc_handshaker_factory_add_handshakers(
     grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory,
     const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) {
-  if (handshaker_factory != NULL) {
-    GPR_ASSERT(handshaker_factory->vtable != NULL);
+  if (handshaker_factory != nullptr) {
+    GPR_ASSERT(handshaker_factory->vtable != nullptr);
     handshaker_factory->vtable->add_handshakers(exec_ctx, handshaker_factory,
                                                 args, handshake_mgr);
   }
@@ -32,8 +32,8 @@ void grpc_handshaker_factory_add_handshakers(
 
 void grpc_handshaker_factory_destroy(
     grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory) {
-  if (handshaker_factory != NULL) {
-    GPR_ASSERT(handshaker_factory->vtable != NULL);
+  if (handshaker_factory != nullptr) {
+    GPR_ASSERT(handshaker_factory->vtable != nullptr);
     handshaker_factory->vtable->destroy(exec_ctx, handshaker_factory);
   }
 }

src/core/lib/compression/stream_compression.cc

@@ -51,7 +51,7 @@ grpc_stream_compression_context* grpc_stream_compression_context_create(
       return grpc_stream_compression_gzip_vtable.context_create(method);
     default:
       gpr_log(GPR_ERROR, "Unknown stream compression method: %d", method);
-      return NULL;
+      return nullptr;
   }
 }
 

src/core/lib/compression/stream_compression_gzip.cc

@@ -137,7 +137,7 @@ static bool grpc_stream_compress_gzip(grpc_stream_compression_context* ctx,
                                       size_t* output_size,
                                       size_t max_output_size,
                                       grpc_stream_compression_flush flush) {
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =
@@ -158,7 +158,7 @@ static bool grpc_stream_compress_gzip(grpc_stream_compression_context* ctx,
       gzip_flush = 0;
   }
   return gzip_flate(gzip_ctx, in, out, output_size, max_output_size, gzip_flush,
-                    NULL);
+                    nullptr);
 }
 
 static bool grpc_stream_decompress_gzip(grpc_stream_compression_context* ctx,
@@ -167,7 +167,7 @@ static bool grpc_stream_decompress_gzip(grpc_stream_compression_context* ctx,
                                         size_t* output_size,
                                         size_t max_output_size,
                                         bool* end_of_context) {
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =
@@ -186,8 +186,8 @@ grpc_stream_compression_context_create_gzip(
       (grpc_stream_compression_context_gzip*)gpr_zalloc(
           sizeof(grpc_stream_compression_context_gzip));
   int r;
-  if (gzip_ctx == NULL) {
-    return NULL;
+  if (gzip_ctx == nullptr) {
+    return nullptr;
   }
   if (method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS) {
     r = inflateInit2(&gzip_ctx->zs, 0x1F);
@@ -199,7 +199,7 @@ grpc_stream_compression_context_create_gzip(
   }
   if (r != Z_OK) {
     gpr_free(gzip_ctx);
-    return NULL;
+    return nullptr;
   }
 
   gzip_ctx->base.vtable = &grpc_stream_compression_gzip_vtable;
@@ -208,7 +208,7 @@ grpc_stream_compression_context_create_gzip(
 
 static void grpc_stream_compression_context_destroy_gzip(
     grpc_stream_compression_context* ctx) {
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     return;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =

src/core/lib/compression/stream_compression_identity.cc

@@ -52,7 +52,7 @@ static bool grpc_stream_compress_identity(grpc_stream_compression_context* ctx,
                                           size_t* output_size,
                                           size_t max_output_size,
                                           grpc_stream_compression_flush flush) {
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_pass_through(in, out, output_size, max_output_size);
@@ -63,7 +63,7 @@ static bool grpc_stream_decompress_identity(
     grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
     grpc_slice_buffer* out, size_t* output_size, size_t max_output_size,
     bool* end_of_context) {
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     return false;
   }
   grpc_stream_compression_pass_through(in, out, output_size, max_output_size);

src/core/lib/debug/stats.cc

@@ -27,7 +27,7 @@
 
 #include "src/core/lib/support/string.h"
 
-grpc_stats_data* grpc_stats_per_cpu_storage = NULL;
+grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
 
 void grpc_stats_init(void) {
@@ -168,7 +168,7 @@ char* grpc_stats_data_as_json(const grpc_stats_data* data) {
     is_first = false;
   }
   gpr_strvec_add(&v, gpr_strdup("}"));
-  tmp = gpr_strvec_flatten(&v, NULL);
+  tmp = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   return tmp;
 }

src/core/lib/debug/trace.cc

@@ -64,7 +64,7 @@ static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
 
 static void split(const char* s, char*** ss, size_t* ns) {
   const char* c = strchr(s, ',');
-  if (c == NULL) {
+  if (c == nullptr) {
     add(s, s + strlen(s), ss, ns);
   } else {
     add(s, c, ss, ns);
@@ -73,7 +73,7 @@ static void split(const char* s, char*** ss, size_t* ns) {
 }
 
 static void parse(const char* s) {
-  char** strings = NULL;
+  char** strings = nullptr;
   size_t nstrings = 0;
   size_t i;
   split(s, &strings, &nstrings);
@@ -102,7 +102,7 @@ static void list_tracers() {
 
 void grpc_tracer_init(const char* env_var) {
   char* e = gpr_getenv(env_var);
-  if (e != NULL) {
+  if (e != nullptr) {
     parse(e);
     gpr_free(e);
   }
@@ -126,7 +126,7 @@ int grpc_tracer_set_enabled(const char* name, int enabled) {
     list_tracers();
   } else if (0 == strcmp(name, "refcount")) {
     for (t = tracers; t; t = t->next) {
-      if (strstr(t->flag->name, "refcount") != NULL) {
+      if (strstr(t->flag->name, "refcount") != nullptr) {
         TRACER_SET(*t->flag, enabled);
       }
     }

src/core/lib/http/httpcli.cc

@@ -60,8 +60,8 @@ typedef struct {
   grpc_resource_quota* resource_quota;
 } internal_request;
 
-static grpc_httpcli_get_override g_get_override = NULL;
-static grpc_httpcli_post_override g_post_override = NULL;
+static grpc_httpcli_get_override g_get_override = nullptr;
+static grpc_httpcli_post_override g_post_override = nullptr;
 
 static void plaintext_handshake(grpc_exec_ctx* exec_ctx, void* arg,
                                 grpc_endpoint* endpoint, const char* host,
@@ -93,10 +93,10 @@ static void finish(grpc_exec_ctx* exec_ctx, internal_request* req,
                                            req->context->pollset_set);
   GRPC_CLOSURE_SCHED(exec_ctx, req->on_done, error);
   grpc_http_parser_destroy(&req->parser);
-  if (req->addresses != NULL) {
+  if (req->addresses != nullptr) {
     grpc_resolved_addresses_destroy(req->addresses);
   }
-  if (req->ep != NULL) {
+  if (req->ep != nullptr) {
     grpc_endpoint_destroy(exec_ctx, req->ep);
   }
   grpc_slice_unref_internal(exec_ctx, req->request_text);
@@ -136,8 +136,8 @@ static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
   for (i = 0; i < req->incoming.count; i++) {
     if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) {
       req->have_read_byte = 1;
-      grpc_error* err =
-          grpc_http_parser_parse(&req->parser, req->incoming.slices[i], NULL);
+      grpc_error* err = grpc_http_parser_parse(
+          &req->parser, req->incoming.slices[i], nullptr);
       if (err != GRPC_ERROR_NONE) {
         finish(exec_ctx, req, err);
         return;

src/core/lib/http/httpcli_security_connector.cc

@@ -42,11 +42,11 @@ static void httpcli_ssl_destroy(grpc_exec_ctx* exec_ctx,
                                 grpc_security_connector* sc) {
   grpc_httpcli_ssl_channel_security_connector* c =
       (grpc_httpcli_ssl_channel_security_connector*)sc;
-  if (c->handshaker_factory != NULL) {
+  if (c->handshaker_factory != nullptr) {
     tsi_ssl_client_handshaker_factory_unref(c->handshaker_factory);
-    c->handshaker_factory = NULL;
+    c->handshaker_factory = nullptr;
   }
-  if (c->secure_peer_name != NULL) gpr_free(c->secure_peer_name);
+  if (c->secure_peer_name != nullptr) gpr_free(c->secure_peer_name);
   gpr_free(sc);
 }
 
@@ -55,8 +55,8 @@ static void httpcli_ssl_add_handshakers(grpc_exec_ctx* exec_ctx,
                                         grpc_handshake_manager* handshake_mgr) {
   grpc_httpcli_ssl_channel_security_connector* c =
       (grpc_httpcli_ssl_channel_security_connector*)sc;
-  tsi_handshaker* handshaker = NULL;
-  if (c->handshaker_factory != NULL) {
+  tsi_handshaker* handshaker = nullptr;
+  if (c->handshaker_factory != nullptr) {
     tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
         c->handshaker_factory, c->secure_peer_name, &handshaker);
     if (result != TSI_OK) {
@@ -79,7 +79,7 @@ static void httpcli_ssl_check_peer(grpc_exec_ctx* exec_ctx,
   grpc_error* error = GRPC_ERROR_NONE;
 
   /* Check the peer name. */
-  if (c->secure_peer_name != NULL &&
+  if (c->secure_peer_name != nullptr &&
       !tsi_ssl_peer_matches_name(&peer, c->secure_peer_name)) {
     char* msg;
     gpr_asprintf(&msg, "Peer name %s is not in peer certificate",
@@ -109,7 +109,7 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
   tsi_result result = TSI_OK;
   grpc_httpcli_ssl_channel_security_connector* c;
 
-  if (secure_peer_name != NULL && pem_root_certs == NULL) {
+  if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR,
             "Cannot assert a secure peer name without a trust root.");
     return GRPC_SECURITY_ERROR;
@@ -120,16 +120,16 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
 
   gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.vtable = &httpcli_ssl_vtable;
-  if (secure_peer_name != NULL) {
+  if (secure_peer_name != nullptr) {
     c->secure_peer_name = gpr_strdup(secure_peer_name);
   }
   result = tsi_create_ssl_client_handshaker_factory(
-      NULL, pem_root_certs, NULL, NULL, 0, &c->handshaker_factory);
+      nullptr, pem_root_certs, nullptr, nullptr, 0, &c->handshaker_factory);
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
     httpcli_ssl_destroy(exec_ctx, &c->base.base);
-    *sc = NULL;
+    *sc = nullptr;
     return GRPC_SECURITY_ERROR;
   }
   // We don't actually need a channel credentials object in this case,
@@ -157,7 +157,7 @@ static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
     const char* msg = grpc_error_string(error);
     gpr_log(GPR_ERROR, "Secure transport setup failed: %s", msg);
 
-    c->func(exec_ctx, c->arg, NULL);
+    c->func(exec_ctx, c->arg, nullptr);
   } else {
     grpc_channel_args_destroy(exec_ctx, args->args);
     grpc_slice_buffer_destroy_internal(exec_ctx, args->read_buffer);
@@ -175,15 +175,15 @@ static void ssl_handshake(grpc_exec_ctx* exec_ctx, void* arg,
                                           grpc_endpoint* endpoint)) {
   on_done_closure* c = (on_done_closure*)gpr_malloc(sizeof(*c));
   const char* pem_root_certs = grpc_get_default_ssl_roots();
-  if (pem_root_certs == NULL) {
+  if (pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(exec_ctx, arg, NULL);
+    on_done(exec_ctx, arg, nullptr);
     gpr_free(c);
     return;
   }
   c->func = on_done;
   c->arg = arg;
-  grpc_channel_security_connector* sc = NULL;
+  grpc_channel_security_connector* sc = nullptr;
   GPR_ASSERT(httpcli_ssl_channel_security_connector_create(
                  exec_ctx, pem_root_certs, host, &sc) == GRPC_SECURITY_OK);
   grpc_arg channel_arg = grpc_security_connector_to_arg(&sc->base);
@@ -191,8 +191,8 @@ static void ssl_handshake(grpc_exec_ctx* exec_ctx, void* arg,
   c->handshake_mgr = grpc_handshake_manager_create();
   grpc_handshakers_add(exec_ctx, HANDSHAKER_CLIENT, &args, c->handshake_mgr);
   grpc_handshake_manager_do_handshake(
-      exec_ctx, c->handshake_mgr, tcp, NULL /* channel_args */, deadline,
-      NULL /* acceptor */, on_handshake_done, c /* user_data */);
+      exec_ctx, c->handshake_mgr, tcp, nullptr /* channel_args */, deadline,
+      nullptr /* acceptor */, on_handshake_done, c /* user_data */);
   GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &sc->base, "httpcli");
 }
 

src/core/lib/http/parser.cc

@@ -152,9 +152,9 @@ static grpc_error* add_header(grpc_http_parser* parser) {
   uint8_t* beg = parser->cur_line;
   uint8_t* cur = beg;
   uint8_t* end = beg + parser->cur_line_length;
-  size_t* hdr_count = NULL;
-  grpc_http_header** hdrs = NULL;
-  grpc_http_header hdr = {NULL, NULL};
+  size_t* hdr_count = nullptr;
+  grpc_http_header** hdrs = nullptr;
+  grpc_http_header hdr = {nullptr, nullptr};
   grpc_error* error = GRPC_ERROR_NONE;
 
   GPR_ASSERT(cur != end);
@@ -240,8 +240,8 @@ static grpc_error* finish_line(grpc_http_parser* parser,
 }
 
 static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) {
-  size_t* body_length = NULL;
-  char** body = NULL;
+  size_t* body_length = nullptr;
+  char** body = nullptr;
 
   if (parser->type == GRPC_HTTP_RESPONSE) {
     body_length = &parser->http.response->body_length;
@@ -352,7 +352,7 @@ grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
     grpc_error* err =
         addbyte(parser, GRPC_SLICE_START_PTR(slice)[i], &found_body_start);
     if (err != GRPC_ERROR_NONE) return err;
-    if (found_body_start && start_of_body != NULL) *start_of_body = i + 1;
+    if (found_body_start && start_of_body != nullptr) *start_of_body = i + 1;
   }
   return GRPC_ERROR_NONE;
 }

src/core/lib/iomgr/call_combiner.cc

@@ -120,7 +120,7 @@ void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
       bool empty;
       grpc_closure* closure = (grpc_closure*)gpr_mpscq_pop_and_check_end(
           &call_combiner->queue, &empty);
-      if (closure == NULL) {
+      if (closure == nullptr) {
         // This can happen either due to a race condition within the mpscq
         // code or because of a race with grpc_call_combiner_start().
         if (GRPC_TRACER_ON(grpc_call_combiner_trace)) {

src/core/lib/iomgr/closure.cc

@@ -43,7 +43,7 @@ grpc_closure* grpc_closure_init(grpc_closure* closure, grpc_iomgr_cb_func cb,
   closure->scheduler = scheduler;
 #ifndef NDEBUG
   closure->scheduled = false;
-  closure->file_initiated = NULL;
+  closure->file_initiated = nullptr;
   closure->line_initiated = 0;
   closure->run = false;
   closure->file_created = file;
@@ -53,18 +53,18 @@ grpc_closure* grpc_closure_init(grpc_closure* closure, grpc_iomgr_cb_func cb,
 }
 
 void grpc_closure_list_init(grpc_closure_list* closure_list) {
-  closure_list->head = closure_list->tail = NULL;
+  closure_list->head = closure_list->tail = nullptr;
 }
 
 bool grpc_closure_list_append(grpc_closure_list* closure_list,
                               grpc_closure* closure, grpc_error* error) {
-  if (closure == NULL) {
+  if (closure == nullptr) {
     GRPC_ERROR_UNREF(error);
     return false;
   }
   closure->error_data.error = error;
-  closure->next_data.next = NULL;
-  bool was_empty = (closure_list->head == NULL);
+  closure->next_data.next = nullptr;
+  bool was_empty = (closure_list->head == nullptr);
   if (was_empty) {
     closure_list->head = closure;
   } else {
@@ -76,7 +76,7 @@ bool grpc_closure_list_append(grpc_closure_list* closure_list,
 
 void grpc_closure_list_fail_all(grpc_closure_list* list,
                                 grpc_error* forced_failure) {
-  for (grpc_closure* c = list->head; c != NULL; c = c->next_data.next) {
+  for (grpc_closure* c = list->head; c != nullptr; c = c->next_data.next) {
     if (c->error_data.error == GRPC_ERROR_NONE) {
       c->error_data.error = GRPC_ERROR_REF(forced_failure);
     }
@@ -85,20 +85,20 @@ void grpc_closure_list_fail_all(grpc_closure_list* list,
 }
 
 bool grpc_closure_list_empty(grpc_closure_list closure_list) {
-  return closure_list.head == NULL;
+  return closure_list.head == nullptr;
 }
 
 void grpc_closure_list_move(grpc_closure_list* src, grpc_closure_list* dst) {
-  if (src->head == NULL) {
+  if (src->head == nullptr) {
     return;
   }
-  if (dst->head == NULL) {
+  if (dst->head == nullptr) {
     *dst = *src;
   } else {
     dst->tail->next_data.next = src->head;
     dst->tail = src->tail;
   }
-  src->head = src->tail = NULL;
+  src->head = src->tail = nullptr;
 }
 
 typedef struct {
@@ -143,7 +143,7 @@ void grpc_closure_run(grpc_exec_ctx* exec_ctx, grpc_closure* c,
                       grpc_error* error) {
 #endif
   GPR_TIMER_BEGIN("grpc_closure_run", 0);
-  if (c != NULL) {
+  if (c != nullptr) {
 #ifndef NDEBUG
     c->file_initiated = file;
     c->line_initiated = line;
@@ -165,7 +165,7 @@ void grpc_closure_sched(grpc_exec_ctx* exec_ctx, grpc_closure* c,
                         grpc_error* error) {
 #endif
   GPR_TIMER_BEGIN("grpc_closure_sched", 0);
-  if (c != NULL) {
+  if (c != nullptr) {
 #ifndef NDEBUG
     if (c->scheduled) {
       gpr_log(GPR_ERROR,
@@ -195,7 +195,7 @@ void grpc_closure_list_sched(const char* file, int line,
 void grpc_closure_list_sched(grpc_exec_ctx* exec_ctx, grpc_closure_list* list) {
 #endif
   grpc_closure* c = list->head;
-  while (c != NULL) {
+  while (c != nullptr) {
     grpc_closure* next = c->next_data.next;
 #ifndef NDEBUG
     if (c->scheduled) {
@@ -215,5 +215,5 @@ void grpc_closure_list_sched(grpc_exec_ctx* exec_ctx, grpc_closure_list* list) {
     c->scheduler->vtable->sched(exec_ctx, c, c->error_data.error);
     c = next;
   }
-  list->head = list->tail = NULL;
+  list->head = list->tail = nullptr;
 }

src/core/lib/iomgr/combiner.cc

@@ -132,8 +132,8 @@ grpc_combiner* grpc_combiner_ref(grpc_combiner* lock GRPC_COMBINER_DEBUG_ARGS) {
 
 static void push_last_on_exec_ctx(grpc_exec_ctx* exec_ctx,
                                   grpc_combiner* lock) {
-  lock->next_combiner_on_this_exec_ctx = NULL;
-  if (exec_ctx->active_combiner == NULL) {
+  lock->next_combiner_on_this_exec_ctx = nullptr;
+  if (exec_ctx->active_combiner == nullptr) {
     exec_ctx->active_combiner = exec_ctx->last_combiner = lock;
   } else {
     exec_ctx->last_combiner->next_combiner_on_this_exec_ctx = lock;
@@ -145,7 +145,7 @@ static void push_first_on_exec_ctx(grpc_exec_ctx* exec_ctx,
                                    grpc_combiner* lock) {
   lock->next_combiner_on_this_exec_ctx = exec_ctx->active_combiner;
   exec_ctx->active_combiner = lock;
-  if (lock->next_combiner_on_this_exec_ctx == NULL) {
+  if (lock->next_combiner_on_this_exec_ctx == nullptr) {
     exec_ctx->last_combiner = lock;
   }
 }
@@ -190,8 +190,8 @@ static void combiner_exec(grpc_exec_ctx* exec_ctx, grpc_closure* cl,
 static void move_next(grpc_exec_ctx* exec_ctx) {
   exec_ctx->active_combiner =
       exec_ctx->active_combiner->next_combiner_on_this_exec_ctx;
-  if (exec_ctx->active_combiner == NULL) {
-    exec_ctx->last_combiner = NULL;
+  if (exec_ctx->active_combiner == nullptr) {
+    exec_ctx->last_combiner = nullptr;
   }
 }
 
@@ -210,7 +210,7 @@ static void queue_offload(grpc_exec_ctx* exec_ctx, grpc_combiner* lock) {
 bool grpc_combiner_continue_exec_ctx(grpc_exec_ctx* exec_ctx) {
   GPR_TIMER_BEGIN("combiner.continue_exec_ctx", 0);
   grpc_combiner* lock = exec_ctx->active_combiner;
-  if (lock == NULL) {
+  if (lock == nullptr) {
     GPR_TIMER_END("combiner.continue_exec_ctx", 0);
     return false;
   }
@@ -244,7 +244,7 @@ bool grpc_combiner_continue_exec_ctx(grpc_exec_ctx* exec_ctx) {
     gpr_mpscq_node* n = gpr_mpscq_pop(&lock->queue);
     GRPC_COMBINER_TRACE(
         gpr_log(GPR_DEBUG, "C:%p maybe_finish_one n=%p", lock, n));
-    if (n == NULL) {
+    if (n == nullptr) {
       // queue is in an inconsistent state: use this as a cue that we should
       // go off and do something else for a while (and come back later)
       GPR_TIMER_MARK("delay_busy", 0);
@@ -263,10 +263,10 @@ bool grpc_combiner_continue_exec_ctx(grpc_exec_ctx* exec_ctx) {
     GPR_TIMER_END("combiner.exec1", 0);
   } else {
     grpc_closure* c = lock->final_list.head;
-    GPR_ASSERT(c != NULL);
+    GPR_ASSERT(c != nullptr);
     grpc_closure_list_init(&lock->final_list);
     int loops = 0;
-    while (c != NULL) {
+    while (c != nullptr) {
       GPR_TIMER_BEGIN("combiner.exec_1final", 0);
       GRPC_COMBINER_TRACE(
           gpr_log(GPR_DEBUG, "C:%p execute_final[%d] c=%p", lock, loops, c));

src/core/lib/iomgr/error.cc

@@ -325,7 +325,7 @@ grpc_error* grpc_error_create(const char* file, int line, grpc_slice desc,
       (uint8_t)(num_referencing * SLOTS_PER_LINKED_ERROR) + SURPLUS_CAPACITY);
   grpc_error* err = (grpc_error*)gpr_malloc(
       sizeof(*err) + initial_arena_capacity * sizeof(intptr_t));
-  if (err == NULL) {  // TODO(ctiller): make gpr_malloc return NULL
+  if (err == nullptr) {  // TODO(ctiller): make gpr_malloc return NULL
     return GRPC_ERROR_OOM;
   }
 #ifndef NDEBUG
@@ -457,7 +457,7 @@ bool grpc_error_get_int(grpc_error* err, grpc_error_ints which, intptr_t* p) {
     if (which == GRPC_ERROR_INT_GRPC_STATUS) {
       for (size_t i = 0; i < GPR_ARRAY_SIZE(error_status_map); i++) {
         if (error_status_map[i].error == err) {
-          if (p != NULL) *p = error_status_map[i].code;
+          if (p != nullptr) *p = error_status_map[i].code;
           GPR_TIMER_END("grpc_error_get_int", 0);
           return true;
         }
@@ -468,7 +468,7 @@ bool grpc_error_get_int(grpc_error* err, grpc_error_ints which, intptr_t* p) {
   }
   uint8_t slot = err->ints[which];
   if (slot != UINT8_MAX) {
-    if (p != NULL) *p = err->arena[slot];
+    if (p != nullptr) *p = err->arena[slot];
     GPR_TIMER_END("grpc_error_get_int", 0);
     return true;
   }
@@ -618,7 +618,7 @@ static char* key_str(grpc_error_strs which) {
 }
 
 static char* fmt_str(grpc_slice slice) {
-  char* s = NULL;
+  char* s = nullptr;
   size_t sz = 0;
   size_t cap = 0;
   append_esc_str((const uint8_t*)GRPC_SLICE_START_PTR(slice),
@@ -688,7 +688,7 @@ static void add_errs(grpc_error* err, char** s, size_t* sz, size_t* cap) {
 }
 
 static char* errs_string(grpc_error* err) {
-  char* s = NULL;
+  char* s = nullptr;
   size_t sz = 0;
   size_t cap = 0;
   append_chr('[', &s, &sz, &cap);
@@ -705,7 +705,7 @@ static int cmp_kvs(const void* a, const void* b) {
 }
 
 static char* finish_kvs(kv_pairs* kvs) {
-  char* s = NULL;
+  char* s = nullptr;
   size_t sz = 0;
   size_t cap = 0;
 
@@ -733,7 +733,7 @@ const char* grpc_error_string(grpc_error* err) {
   if (err == GRPC_ERROR_CANCELLED) return cancelled_error_string;
 
   void* p = (void*)gpr_atm_acq_load(&err->atomics.error_string);
-  if (p != NULL) {
+  if (p != nullptr) {
     GPR_TIMER_END("grpc_error_string", 0);
     return (const char*)p;
   }
@@ -767,8 +767,8 @@ grpc_error* grpc_os_error(const char* file, int line, int err,
       grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_create(file, line,
-                                grpc_slice_from_static_string("OS Error"), NULL,
-                                0),
+                                grpc_slice_from_static_string("OS Error"),
+                                nullptr, 0),
               GRPC_ERROR_INT_ERRNO, err),
           GRPC_ERROR_STR_OS_ERROR,
           grpc_slice_from_static_string(strerror(err))),

src/core/lib/iomgr/error.h

@@ -24,6 +24,7 @@
 
 #include <grpc/slice.h>
 #include <grpc/status.h>
+#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -184,9 +185,15 @@ grpc_error* grpc_error_add_child(grpc_error* src,
                                  grpc_error* child) GRPC_MUST_USE_RESULT;
 grpc_error* grpc_os_error(const char* file, int line, int err,
                           const char* call_name) GRPC_MUST_USE_RESULT;
+
+inline grpc_error* grpc_assert_never_ok(grpc_error* error) {
+  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  return error;
+}
+
 /// create an error associated with errno!=0 (an 'operating system' error)
 #define GRPC_OS_ERROR(err, call_name) \
-  grpc_os_error(__FILE__, __LINE__, err, call_name)
+  grpc_assert_never_ok(grpc_os_error(__FILE__, __LINE__, err, call_name))
 grpc_error* grpc_wsa_error(const char* file, int line, int err,
                            const char* call_name) GRPC_MUST_USE_RESULT;
 /// windows only: create an error associated with WSAGetLastError()!=0

src/core/lib/iomgr/error_internal.h

@@ -23,6 +23,7 @@
 #include <stdbool.h>  // TODO, do we need this?
 
 #include <grpc/support/sync.h>
+#include "src/core/lib/iomgr/error.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -59,7 +60,7 @@ struct grpc_error {
   intptr_t arena[0];
 };
 
-bool grpc_error_is_special(grpc_error* err);
+bool grpc_error_is_special(struct grpc_error* err);
 
 #ifdef __cplusplus
 }

src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -18,6 +18,8 @@
 
 #include "src/core/lib/iomgr/port.h"
 
+#include <grpc/support/log.h>
+
 /* This polling engine is only relevant on linux kernels supporting epoll() */
 #ifdef GRPC_LINUX_EPOLL
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
@@ -34,7 +36,6 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/tls.h>
 #include <grpc/support/useful.h>
@@ -234,7 +235,7 @@ static bool append_error(grpc_error** composite, grpc_error* error,
  * alarm 'epoch'). This wakeup_fd gives us something to alert on when such a
  * case occurs. */
 
-static grpc_fd* fd_freelist = NULL;
+static grpc_fd* fd_freelist = nullptr;
 static gpr_mu fd_freelist_mu;
 
 static void fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
@@ -242,7 +243,7 @@ static void fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
 static void fd_global_shutdown(void) {
   gpr_mu_lock(&fd_freelist_mu);
   gpr_mu_unlock(&fd_freelist_mu);
-  while (fd_freelist != NULL) {
+  while (fd_freelist != nullptr) {
     grpc_fd* fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
     gpr_free(fd);
@@ -251,16 +252,16 @@ static void fd_global_shutdown(void) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name) {
-  grpc_fd* new_fd = NULL;
+  grpc_fd* new_fd = nullptr;
 
   gpr_mu_lock(&fd_freelist_mu);
-  if (fd_freelist != NULL) {
+  if (fd_freelist != nullptr) {
     new_fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
   }
   gpr_mu_unlock(&fd_freelist_mu);
 
-  if (new_fd == NULL) {
+  if (new_fd == nullptr) {
     new_fd = (grpc_fd*)gpr_malloc(sizeof(grpc_fd));
   }
 
@@ -269,7 +270,7 @@ static grpc_fd* fd_create(int fd, const char* name) {
   new_fd->write_closure.Init();
   gpr_atm_no_barrier_store(&new_fd->read_notifier_pollset, (gpr_atm)NULL);
 
-  new_fd->freelist_next = NULL;
+  new_fd->freelist_next = nullptr;
 
   char* fd_name;
   gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
@@ -316,7 +317,7 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
                       grpc_closure* on_done, int* release_fd,
                       bool already_closed, const char* reason) {
   grpc_error* error = GRPC_ERROR_NONE;
-  bool is_release_fd = (release_fd != NULL);
+  bool is_release_fd = (release_fd != nullptr);
 
   if (!fd->read_closure->IsShutdown()) {
     fd_shutdown_internal(exec_ctx, fd,
@@ -390,7 +391,7 @@ static size_t g_num_neighborhoods;
 
 /* Return true if first in list */
 static bool worker_insert(grpc_pollset* pollset, grpc_pollset_worker* worker) {
-  if (pollset->root_worker == NULL) {
+  if (pollset->root_worker == nullptr) {
     pollset->root_worker = worker;
     worker->next = worker->prev = worker;
     return true;
@@ -410,7 +411,7 @@ static worker_remove_result worker_remove(grpc_pollset* pollset,
                                           grpc_pollset_worker* worker) {
   if (worker == pollset->root_worker) {
     if (worker == worker->next) {
-      pollset->root_worker = NULL;
+      pollset->root_worker = nullptr;
       return EMPTIED;
     } else {
       pollset->root_worker = worker->next;
@@ -467,13 +468,13 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   *mu = &pollset->mu;
   pollset->neighborhood = &g_neighborhoods[choose_neighborhood()];
   pollset->reassigning_neighborhood = false;
-  pollset->root_worker = NULL;
+  pollset->root_worker = nullptr;
   pollset->kicked_without_poller = false;
   pollset->seen_inactive = true;
   pollset->shutting_down = false;
-  pollset->shutdown_closure = NULL;
+  pollset->shutdown_closure = nullptr;
   pollset->begin_refs = 0;
-  pollset->next = pollset->prev = NULL;
+  pollset->next = pollset->prev = nullptr;
 }
 
 static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
@@ -495,7 +496,7 @@ static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
       pollset->next->prev = pollset->prev;
       if (pollset == pollset->neighborhood->active_root) {
         pollset->neighborhood->active_root =
-            pollset->next == pollset ? NULL : pollset->next;
+            pollset->next == pollset ? nullptr : pollset->next;
       }
     }
     gpr_mu_unlock(&pollset->neighborhood->mu);
@@ -508,7 +509,7 @@ static grpc_error* pollset_kick_all(grpc_exec_ctx* exec_ctx,
                                     grpc_pollset* pollset) {
   GPR_TIMER_BEGIN("pollset_kick_all", 0);
   grpc_error* error = GRPC_ERROR_NONE;
-  if (pollset->root_worker != NULL) {
+  if (pollset->root_worker != nullptr) {
     grpc_pollset_worker* worker = pollset->root_worker;
     do {
       GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
@@ -542,18 +543,18 @@ static grpc_error* pollset_kick_all(grpc_exec_ctx* exec_ctx,
 
 static void pollset_maybe_finish_shutdown(grpc_exec_ctx* exec_ctx,
                                           grpc_pollset* pollset) {
-  if (pollset->shutdown_closure != NULL && pollset->root_worker == NULL &&
+  if (pollset->shutdown_closure != nullptr && pollset->root_worker == nullptr &&
       pollset->begin_refs == 0) {
     GPR_TIMER_MARK("pollset_finish_shutdown", 0);
     GRPC_CLOSURE_SCHED(exec_ctx, pollset->shutdown_closure, GRPC_ERROR_NONE);
-    pollset->shutdown_closure = NULL;
+    pollset->shutdown_closure = nullptr;
   }
 }
 
 static void pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
                              grpc_closure* closure) {
   GPR_TIMER_BEGIN("pollset_shutdown", 0);
-  GPR_ASSERT(pollset->shutdown_closure == NULL);
+  GPR_ASSERT(pollset->shutdown_closure == nullptr);
   GPR_ASSERT(!pollset->shutting_down);
   pollset->shutdown_closure = closure;
   pollset->shutting_down = true;
@@ -666,7 +667,7 @@ static bool begin_worker(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
                          grpc_pollset_worker** worker_hdl,
                          grpc_millis deadline) {
   GPR_TIMER_BEGIN("begin_worker", 0);
-  if (worker_hdl != NULL) *worker_hdl = worker;
+  if (worker_hdl != nullptr) *worker_hdl = worker;
   worker->initialized_cv = false;
   SET_KICK_STATE(worker, UNKICKED);
   worker->schedule_on_end_work = (grpc_closure_list)GRPC_CLOSURE_LIST_INIT;
@@ -715,7 +716,7 @@ static bool begin_worker(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
          not visible in the "kick any" path yet */
       if (worker->state == UNKICKED) {
         pollset->seen_inactive = false;
-        if (neighborhood->active_root == NULL) {
+        if (neighborhood->active_root == nullptr) {
           neighborhood->active_root = pollset->next = pollset->prev = pollset;
           /* Make this the designated poller if there isn't one already */
           if (worker->state == UNKICKED &&
@@ -793,13 +794,13 @@ static bool check_neighborhood_for_available_poller(
   bool found_worker = false;
   do {
     grpc_pollset* inspect = neighborhood->active_root;
-    if (inspect == NULL) {
+    if (inspect == nullptr) {
       break;
     }
     gpr_mu_lock(&inspect->mu);
     GPR_ASSERT(!inspect->seen_inactive);
     grpc_pollset_worker* inspect_worker = inspect->root_worker;
-    if (inspect_worker != NULL) {
+    if (inspect_worker != nullptr) {
       do {
         switch (inspect_worker->state) {
           case UNKICKED:
@@ -840,11 +841,11 @@ static bool check_neighborhood_for_available_poller(
       inspect->seen_inactive = true;
       if (inspect == neighborhood->active_root) {
         neighborhood->active_root =
-            inspect->next == inspect ? NULL : inspect->next;
+            inspect->next == inspect ? nullptr : inspect->next;
       }
       inspect->next->prev = inspect->prev;
       inspect->prev->next = inspect->next;
-      inspect->next = inspect->prev = NULL;
+      inspect->next = inspect->prev = nullptr;
     }
     gpr_mu_unlock(&inspect->mu);
   } while (!found_worker);
@@ -859,7 +860,7 @@ static void end_worker(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
   if (GRPC_TRACER_ON(grpc_polling_trace)) {
     gpr_log(GPR_DEBUG, "PS:%p END_WORKER:%p", pollset, worker);
   }
-  if (worker_hdl != NULL) *worker_hdl = NULL;
+  if (worker_hdl != nullptr) *worker_hdl = nullptr;
   /* Make sure we appear kicked */
   SET_KICK_STATE(worker, KICKED);
   grpc_closure_list_move(&worker->schedule_on_end_work,
@@ -1001,28 +1002,28 @@ static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
                  (void*)gpr_tls_get(&g_current_thread_worker),
                  pollset->root_worker);
     gpr_strvec_add(&log, tmp);
-    if (pollset->root_worker != NULL) {
+    if (pollset->root_worker != nullptr) {
       gpr_asprintf(&tmp, " {kick_state=%s next=%p {kick_state=%s}}",
                    kick_state_string(pollset->root_worker->state),
                    pollset->root_worker->next,
                    kick_state_string(pollset->root_worker->next->state));
       gpr_strvec_add(&log, tmp);
     }
-    if (specific_worker != NULL) {
+    if (specific_worker != nullptr) {
       gpr_asprintf(&tmp, " worker_kick_state=%s",
                    kick_state_string(specific_worker->state));
       gpr_strvec_add(&log, tmp);
     }
-    tmp = gpr_strvec_flatten(&log, NULL);
+    tmp = gpr_strvec_flatten(&log, nullptr);
     gpr_strvec_destroy(&log);
     gpr_log(GPR_ERROR, "%s", tmp);
     gpr_free(tmp);
   }
 
-  if (specific_worker == NULL) {
+  if (specific_worker == nullptr) {
     if (gpr_tls_get(&g_current_thread_pollset) != (intptr_t)pollset) {
       grpc_pollset_worker* root_worker = pollset->root_worker;
-      if (root_worker == NULL) {
+      if (root_worker == nullptr) {
         GRPC_STATS_INC_POLLSET_KICKED_WITHOUT_POLLER(exec_ctx);
         pollset->kicked_without_poller = true;
         if (GRPC_TRACER_ON(grpc_polling_trace)) {
@@ -1230,11 +1231,12 @@ static const grpc_event_engine_vtable vtable = {
  * support is available */
 const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
   if (!grpc_has_wakeup_fd()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping epoll1 because of no wakeup fd.");
+    return nullptr;
   }
 
   if (!epoll_set_init()) {
-    return NULL;
+    return nullptr;
   }
 
   fd_global_init();
@@ -1242,7 +1244,7 @@ const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
     fd_global_shutdown();
     epoll_set_shutdown();
-    return NULL;
+    return nullptr;
   }
 
   return &vtable;
@@ -1254,6 +1256,8 @@ const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
 /* If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
  * NULL */
 const grpc_event_engine_vtable* grpc_init_epoll1_linux(bool explicit_request) {
+  gpr_log(GPR_ERROR,
+          "Skipping epoll1 becuase GRPC_LINUX_EPOLL is not defined.");
   return NULL;
 }
 #endif /* defined(GRPC_POSIX_SOCKET) */

src/core/lib/iomgr/ev_epollex_linux.cc

@@ -18,6 +18,8 @@
 
 #include "src/core/lib/iomgr/port.h"
 
+#include <grpc/support/log.h>
+
 /* This polling engine is only relevant on linux kernels supporting epoll() */
 #ifdef GRPC_LINUX_EPOLL
 
@@ -34,7 +36,6 @@
 #include <unistd.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/tls.h>
 #include <grpc/support/useful.h>
@@ -253,7 +254,7 @@ static bool append_error(grpc_error** composite, grpc_error* error,
  * becomes a spurious read notification on a reused fd.
  */
 
-static grpc_fd* fd_freelist = NULL;
+static grpc_fd* fd_freelist = nullptr;
 static gpr_mu fd_freelist_mu;
 
 #ifndef NDEBUG
@@ -321,7 +322,7 @@ static void fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
 static void fd_global_shutdown(void) {
   gpr_mu_lock(&fd_freelist_mu);
   gpr_mu_unlock(&fd_freelist_mu);
-  while (fd_freelist != NULL) {
+  while (fd_freelist != nullptr) {
     grpc_fd* fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
     gpr_free(fd);
@@ -330,30 +331,30 @@ static void fd_global_shutdown(void) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name) {
-  grpc_fd* new_fd = NULL;
+  grpc_fd* new_fd = nullptr;
 
   gpr_mu_lock(&fd_freelist_mu);
-  if (fd_freelist != NULL) {
+  if (fd_freelist != nullptr) {
     new_fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
   }
   gpr_mu_unlock(&fd_freelist_mu);
 
-  if (new_fd == NULL) {
+  if (new_fd == nullptr) {
     new_fd = (grpc_fd*)gpr_malloc(sizeof(grpc_fd));
   }
 
   gpr_mu_init(&new_fd->pollable_mu);
   gpr_mu_init(&new_fd->orphan_mu);
-  new_fd->pollable_obj = NULL;
+  new_fd->pollable_obj = nullptr;
   gpr_atm_rel_store(&new_fd->refst, (gpr_atm)1);
   new_fd->fd = fd;
   new_fd->read_closure.Init();
   new_fd->write_closure.Init();
   gpr_atm_no_barrier_store(&new_fd->read_notifier_pollset, (gpr_atm)NULL);
 
-  new_fd->freelist_next = NULL;
-  new_fd->on_done_closure = NULL;
+  new_fd->freelist_next = nullptr;
+  new_fd->on_done_closure = nullptr;
 
   char* fd_name;
   gpr_asprintf(&fd_name, "%s fd=%d", name, fd);
@@ -383,7 +384,7 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
 
   /* If release_fd is not NULL, we should be relinquishing control of the file
      descriptor fd->fd (but we still own the grpc_fd structure). */
-  if (release_fd != NULL) {
+  if (release_fd != nullptr) {
     *release_fd = fd->fd;
   } else if (!is_fd_closed) {
     close(fd->fd);
@@ -439,7 +440,7 @@ static void fd_notify_on_write(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
  */
 
 static grpc_error* pollable_create(pollable_type type, pollable** p) {
-  *p = NULL;
+  *p = nullptr;
 
   int epfd = epoll_create1(EPOLL_CLOEXEC);
   if (epfd == -1) {
@@ -450,7 +451,7 @@ static grpc_error* pollable_create(pollable_type type, pollable** p) {
   if (err != GRPC_ERROR_NONE) {
     close(epfd);
     gpr_free(*p);
-    *p = NULL;
+    *p = nullptr;
     return err;
   }
   struct epoll_event ev;
@@ -461,7 +462,7 @@ static grpc_error* pollable_create(pollable_type type, pollable** p) {
     close(epfd);
     grpc_wakeup_fd_destroy(&(*p)->wakeup);
     gpr_free(*p);
-    *p = NULL;
+    *p = nullptr;
     return err;
   }
 
@@ -469,10 +470,10 @@ static grpc_error* pollable_create(pollable_type type, pollable** p) {
   gpr_ref_init(&(*p)->refs, 1);
   gpr_mu_init(&(*p)->mu);
   (*p)->epfd = epfd;
-  (*p)->owner_fd = NULL;
-  (*p)->pollset_set = NULL;
+  (*p)->owner_fd = nullptr;
+  (*p)->pollset_set = nullptr;
   (*p)->next = (*p)->prev = *p;
-  (*p)->root_worker = NULL;
+  (*p)->root_worker = nullptr;
   (*p)->event_cursor = 0;
   (*p)->event_count = 0;
   return GRPC_ERROR_NONE;
@@ -496,14 +497,14 @@ static pollable* pollable_ref(pollable* p, int line, const char* reason) {
 static void pollable_unref(pollable* p) {
 #else
 static void pollable_unref(pollable* p, int line, const char* reason) {
-  if (p == NULL) return;
+  if (p == nullptr) return;
   if (GRPC_TRACER_ON(grpc_trace_pollable_refcount)) {
     int r = (int)gpr_atm_no_barrier_load(&p->refs.count);
     gpr_log(__FILE__, line, GPR_LOG_SEVERITY_DEBUG,
             "POLLABLE:%p unref %d->%d %s", p, r, r - 1, reason);
   }
 #endif
-  if (p != NULL && gpr_unref(&p->refs)) {
+  if (p != nullptr && gpr_unref(&p->refs)) {
     close(p->epfd);
     grpc_wakeup_fd_destroy(&p->wakeup);
     gpr_free(p);
@@ -564,10 +565,10 @@ static void pollset_maybe_finish_shutdown(grpc_exec_ctx* exec_ctx,
             pollset, pollset->active_pollable, pollset->shutdown_closure,
             pollset->root_worker, pollset->containing_pollset_set_count);
   }
-  if (pollset->shutdown_closure != NULL && pollset->root_worker == NULL &&
+  if (pollset->shutdown_closure != nullptr && pollset->root_worker == nullptr &&
       pollset->containing_pollset_set_count == 0) {
     GRPC_CLOSURE_SCHED(exec_ctx, pollset->shutdown_closure, GRPC_ERROR_NONE);
-    pollset->shutdown_closure = NULL;
+    pollset->shutdown_closure = nullptr;
   }
 }
 
@@ -578,7 +579,7 @@ static grpc_error* kick_one_worker(grpc_exec_ctx* exec_ctx,
                                    grpc_pollset_worker* specific_worker) {
   pollable* p = specific_worker->pollable_obj;
   grpc_core::mu_guard lock(&p->mu);
-  GPR_ASSERT(specific_worker != NULL);
+  GPR_ASSERT(specific_worker != nullptr);
   if (specific_worker->kicked) {
     if (GRPC_TRACER_ON(grpc_polling_trace)) {
       gpr_log(GPR_DEBUG, "PS:%p kicked_specific_but_already_kicked", p);
@@ -627,9 +628,9 @@ static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
             (void*)gpr_tls_get(&g_current_thread_pollset),
             (void*)gpr_tls_get(&g_current_thread_worker), pollset->root_worker);
   }
-  if (specific_worker == NULL) {
+  if (specific_worker == nullptr) {
     if (gpr_tls_get(&g_current_thread_pollset) != (intptr_t)pollset) {
-      if (pollset->root_worker == NULL) {
+      if (pollset->root_worker == nullptr) {
         if (GRPC_TRACER_ON(grpc_polling_trace)) {
           gpr_log(GPR_DEBUG, "PS:%p kicked_any_without_poller", pollset);
         }
@@ -672,7 +673,7 @@ static grpc_error* pollset_kick_all(grpc_exec_ctx* exec_ctx,
   grpc_error* error = GRPC_ERROR_NONE;
   const char* err_desc = "pollset_kick_all";
   grpc_pollset_worker* w = pollset->root_worker;
-  if (w != NULL) {
+  if (w != nullptr) {
     do {
       GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
       append_error(&error, kick_one_worker(exec_ctx, w), err_desc);
@@ -721,23 +722,23 @@ static grpc_error* fd_get_or_become_pollable(grpc_fd* fd, pollable** p) {
   gpr_mu_lock(&fd->pollable_mu);
   grpc_error* error = GRPC_ERROR_NONE;
   static const char* err_desc = "fd_get_or_become_pollable";
-  if (fd->pollable_obj == NULL) {
+  if (fd->pollable_obj == nullptr) {
     if (append_error(&error, pollable_create(PO_FD, &fd->pollable_obj),
                      err_desc)) {
       fd->pollable_obj->owner_fd = fd;
       if (!append_error(&error, pollable_add_fd(fd->pollable_obj, fd),
                         err_desc)) {
         POLLABLE_UNREF(fd->pollable_obj, "fd_pollable");
-        fd->pollable_obj = NULL;
+        fd->pollable_obj = nullptr;
       }
     }
   }
   if (error == GRPC_ERROR_NONE) {
-    GPR_ASSERT(fd->pollable_obj != NULL);
+    GPR_ASSERT(fd->pollable_obj != nullptr);
     *p = POLLABLE_REF(fd->pollable_obj, "pollset");
   } else {
-    GPR_ASSERT(fd->pollable_obj == NULL);
-    *p = NULL;
+    GPR_ASSERT(fd->pollable_obj == nullptr);
+    *p = nullptr;
   }
   gpr_mu_unlock(&fd->pollable_mu);
   return error;
@@ -746,7 +747,7 @@ static grpc_error* fd_get_or_become_pollable(grpc_fd* fd, pollable** p) {
 /* pollset->po.mu lock must be held by the caller before calling this */
 static void pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
                              grpc_closure* closure) {
-  GPR_ASSERT(pollset->shutdown_closure == NULL);
+  GPR_ASSERT(pollset->shutdown_closure == nullptr);
   pollset->shutdown_closure = closure;
   GRPC_LOG_IF_ERROR("pollset_shutdown", pollset_kick_all(exec_ctx, pollset));
   pollset_maybe_finish_shutdown(exec_ctx, pollset);
@@ -797,7 +798,7 @@ static grpc_error* pollable_process_events(grpc_exec_ctx* exec_ctx,
 /* pollset_shutdown is guaranteed to be called before pollset_destroy. */
 static void pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
   POLLABLE_UNREF(pollset->active_pollable, "pollset");
-  pollset->active_pollable = NULL;
+  pollset->active_pollable = nullptr;
 }
 
 static grpc_error* pollable_epoll(grpc_exec_ctx* exec_ctx, pollable* p,
@@ -837,7 +838,7 @@ static grpc_error* pollable_epoll(grpc_exec_ctx* exec_ctx, pollable* p,
 /* Return true if first in list */
 static bool worker_insert(grpc_pollset_worker** root_worker,
                           grpc_pollset_worker* worker, pwlinks link) {
-  if (*root_worker == NULL) {
+  if (*root_worker == nullptr) {
     *root_worker = worker;
     worker->links[link].next = worker->links[link].prev = worker;
     return true;
@@ -858,7 +859,7 @@ static worker_remove_result worker_remove(grpc_pollset_worker** root_worker,
                                           pwlinks link) {
   if (worker == *root_worker) {
     if (worker == worker->links[link].next) {
-      *root_worker = NULL;
+      *root_worker = nullptr;
       return WRR_EMPTIED;
     } else {
       *root_worker = worker->links[link].next;
@@ -879,7 +880,7 @@ static bool begin_worker(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
                          grpc_pollset_worker** worker_hdl,
                          grpc_millis deadline) {
   bool do_poll = (pollset->shutdown_closure == nullptr);
-  if (worker_hdl != NULL) *worker_hdl = worker;
+  if (worker_hdl != nullptr) *worker_hdl = worker;
   worker->initialized_cv = false;
   worker->kicked = false;
   worker->pollset = pollset;
@@ -1052,12 +1053,12 @@ static grpc_error* pollset_transition_pollable_from_fd_to_multi_locked(
   append_error(&error, pollset_kick_all(exec_ctx, pollset), err_desc);
   grpc_fd* initial_fd = pollset->active_pollable->owner_fd;
   POLLABLE_UNREF(pollset->active_pollable, "pollset");
-  pollset->active_pollable = NULL;
+  pollset->active_pollable = nullptr;
   if (append_error(&error, pollable_create(PO_MULTI, &pollset->active_pollable),
                    err_desc)) {
     append_error(&error, pollable_add_fd(pollset->active_pollable, initial_fd),
                  err_desc);
-    if (and_add_fd != NULL) {
+    if (and_add_fd != nullptr) {
       append_error(&error,
                    pollable_add_fd(pollset->active_pollable, and_add_fd),
                    err_desc);
@@ -1123,7 +1124,7 @@ static grpc_error* pollset_as_multipollable_locked(grpc_exec_ctx* exec_ctx,
         error = pollable_create(PO_MULTI, &pollset->active_pollable);
       } else {
         error = pollset_transition_pollable_from_fd_to_multi_locked(
-            exec_ctx, pollset, NULL);
+            exec_ctx, pollset, nullptr);
       }
       gpr_mu_unlock(&po_at_start->owner_fd->orphan_mu);
       break;
@@ -1133,7 +1134,7 @@ static grpc_error* pollset_as_multipollable_locked(grpc_exec_ctx* exec_ctx,
   if (error != GRPC_ERROR_NONE) {
     POLLABLE_UNREF(pollset->active_pollable, "pollset");
     pollset->active_pollable = po_at_start;
-    *pollable_obj = NULL;
+    *pollable_obj = nullptr;
   } else {
     *pollable_obj = POLLABLE_REF(pollset->active_pollable, "pollset_set");
     POLLABLE_UNREF(po_at_start, "pollset_as_multipollable");
@@ -1155,7 +1156,7 @@ static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
 
 static grpc_pollset_set* pss_lock_adam(grpc_pollset_set* pss) {
   gpr_mu_lock(&pss->mu);
-  while (pss->parent != NULL) {
+  while (pss->parent != nullptr) {
     gpr_mu_unlock(&pss->mu);
     pss = pss->parent;
     gpr_mu_lock(&pss->mu);
@@ -1171,7 +1172,7 @@ static grpc_pollset_set* pollset_set_create(void) {
 }
 
 static void pollset_set_unref(grpc_exec_ctx* exec_ctx, grpc_pollset_set* pss) {
-  if (pss == NULL) return;
+  if (pss == nullptr) return;
   if (!gpr_unref(&pss->refs)) return;
   pollset_set_unref(exec_ctx, pss->parent);
   gpr_mu_destroy(&pss->mu);
@@ -1293,11 +1294,11 @@ static void pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
   }
   grpc_error* error = GRPC_ERROR_NONE;
   static const char* err_desc = "pollset_set_add_pollset";
-  pollable* pollable_obj = NULL;
+  pollable* pollable_obj = nullptr;
   gpr_mu_lock(&ps->mu);
   if (!GRPC_LOG_IF_ERROR(err_desc, pollset_as_multipollable_locked(
                                        exec_ctx, ps, &pollable_obj))) {
-    GPR_ASSERT(pollable_obj == NULL);
+    GPR_ASSERT(pollable_obj == nullptr);
     gpr_mu_unlock(&ps->mu);
     return;
   }
@@ -1342,9 +1343,9 @@ static void pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
     gpr_mu* b_mu = &b->mu;
     gpr_mu_lock(a_mu);
     gpr_mu_lock(b_mu);
-    if (a->parent != NULL) {
+    if (a->parent != nullptr) {
       a = a->parent;
-    } else if (b->parent != NULL) {
+    } else if (b->parent != nullptr) {
       b = b->parent;
     } else {
       break;  // exit loop, both pollsets locked
@@ -1393,8 +1394,8 @@ static void pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
   a->pollset_count += b->pollset_count;
   gpr_free(b->fds);
   gpr_free(b->pollsets);
-  b->fds = NULL;
-  b->pollsets = NULL;
+  b->fds = nullptr;
+  b->pollsets = nullptr;
   b->fd_count = b->fd_capacity = b->pollset_count = b->pollset_capacity = 0;
   gpr_mu_unlock(&a->mu);
   gpr_mu_unlock(&b->mu);
@@ -1447,15 +1448,17 @@ static const grpc_event_engine_vtable vtable = {
 const grpc_event_engine_vtable* grpc_init_epollex_linux(
     bool explicitly_requested) {
   if (!explicitly_requested) {
-    return NULL;
+    return nullptr;
   }
 
   if (!grpc_has_wakeup_fd()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping epollex because of no wakeup fd.");
+    return nullptr;
   }
 
   if (!grpc_is_epollexclusive_available()) {
-    return NULL;
+    gpr_log(GPR_INFO, "Skipping epollex because it is not supported.");
+    return nullptr;
   }
 
 #ifndef NDEBUG
@@ -1467,7 +1470,7 @@ const grpc_event_engine_vtable* grpc_init_epollex_linux(
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
     pollset_global_shutdown();
     fd_global_shutdown();
-    return NULL;
+    return nullptr;
   }
 
   return &vtable;
@@ -1480,6 +1483,8 @@ const grpc_event_engine_vtable* grpc_init_epollex_linux(
  * NULL */
 const grpc_event_engine_vtable* grpc_init_epollex_linux(
     bool explicitly_requested) {
+  gpr_log(GPR_ERROR,
+          "Skipping epollex becuase GRPC_LINUX_EPOLL is not defined.");
   return NULL;
 }
 #endif /* defined(GRPC_POSIX_SOCKET) */

src/core/lib/iomgr/ev_epollsig_linux.cc

@@ -19,6 +19,7 @@
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/grpc_posix.h>
+#include <grpc/support/log.h>
 
 /* This polling engine is only relevant on linux kernels supporting epoll() */
 #ifdef GRPC_LINUX_EPOLL
@@ -37,7 +38,6 @@
 #include <unistd.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/tls.h>
 #include <grpc/support/useful.h>
@@ -328,7 +328,7 @@ static void pi_unref(grpc_exec_ctx* exec_ctx, polling_island* pi) {
   if (1 == gpr_atm_full_fetch_add(&pi->ref_count, -1)) {
     polling_island* next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
     polling_island_delete(exec_ctx, pi);
-    if (next != NULL) {
+    if (next != nullptr) {
       PI_UNREF(exec_ctx, next, "pi_delete"); /* Recursive call */
     }
   }
@@ -414,7 +414,7 @@ static void polling_island_remove_all_fds_locked(polling_island* pi,
   const char* err_desc = "polling_island_remove_fds";
 
   for (i = 0; i < pi->fd_cnt; i++) {
-    err = epoll_ctl(pi->epoll_fd, EPOLL_CTL_DEL, pi->fds[i]->fd, NULL);
+    err = epoll_ctl(pi->epoll_fd, EPOLL_CTL_DEL, pi->fds[i]->fd, nullptr);
     if (err < 0 && errno != ENOENT) {
       gpr_asprintf(&err_msg,
                    "epoll_ctl (epoll_fd: %d) delete fds[%zu]: %d failed with "
@@ -444,7 +444,7 @@ static void polling_island_remove_fd_locked(polling_island* pi, grpc_fd* fd,
   /* If fd is already closed, then it would have been automatically been removed
      from the epoll set */
   if (!is_fd_closed) {
-    err = epoll_ctl(pi->epoll_fd, EPOLL_CTL_DEL, fd->fd, NULL);
+    err = epoll_ctl(pi->epoll_fd, EPOLL_CTL_DEL, fd->fd, nullptr);
     if (err < 0 && errno != ENOENT) {
       gpr_asprintf(
           &err_msg,
@@ -468,7 +468,7 @@ static void polling_island_remove_fd_locked(polling_island* pi, grpc_fd* fd,
 static polling_island* polling_island_create(grpc_exec_ctx* exec_ctx,
                                              grpc_fd* initial_fd,
                                              grpc_error** error) {
-  polling_island* pi = NULL;
+  polling_island* pi = nullptr;
   const char* err_desc = "polling_island_create";
 
   *error = GRPC_ERROR_NONE;
@@ -477,7 +477,7 @@ static polling_island* polling_island_create(grpc_exec_ctx* exec_ctx,
   gpr_mu_init(&pi->mu);
   pi->fd_cnt = 0;
   pi->fd_capacity = 0;
-  pi->fds = NULL;
+  pi->fds = nullptr;
   pi->epoll_fd = -1;
 
   gpr_atm_rel_store(&pi->ref_count, 0);
@@ -491,14 +491,14 @@ static polling_island* polling_island_create(grpc_exec_ctx* exec_ctx,
     goto done;
   }
 
-  if (initial_fd != NULL) {
+  if (initial_fd != nullptr) {
     polling_island_add_fds_locked(pi, &initial_fd, 1, true, error);
   }
 
 done:
   if (*error != GRPC_ERROR_NONE) {
     polling_island_delete(exec_ctx, pi);
-    pi = NULL;
+    pi = nullptr;
   }
   return pi;
 }
@@ -519,7 +519,7 @@ static void polling_island_delete(grpc_exec_ctx* exec_ctx, polling_island* pi) {
  * guarantees that the island returned is the last island */
 static polling_island* polling_island_maybe_get_latest(polling_island* pi) {
   polling_island* next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
-  while (next != NULL) {
+  while (next != nullptr) {
     pi = next;
     next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
   }
@@ -537,18 +537,18 @@ static polling_island* polling_island_maybe_get_latest(polling_island* pi) {
       ...
       gpr_mu_unlock(&pi_latest->mu); // NOTE: use pi_latest->mu. NOT pi->mu */
 static polling_island* polling_island_lock(polling_island* pi) {
-  polling_island* next = NULL;
+  polling_island* next = nullptr;
 
   while (true) {
     next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
-    if (next == NULL) {
+    if (next == nullptr) {
       /* Looks like 'pi' is the last node in the linked list but unless we check
          this by holding the pi->mu lock, we cannot be sure (i.e without the
          pi->mu lock, we don't prevent island merges).
          To be absolutely sure, check once more by holding the pi->mu lock */
       gpr_mu_lock(&pi->mu);
       next = (polling_island*)gpr_atm_acq_load(&pi->merged_to);
-      if (next == NULL) {
+      if (next == nullptr) {
         /* pi is infact the last node and we have the pi->mu lock. we're done */
         break;
       }
@@ -588,8 +588,8 @@ static polling_island* polling_island_lock(polling_island* pi) {
 static void polling_island_lock_pair(polling_island** p, polling_island** q) {
   polling_island* pi_1 = *p;
   polling_island* pi_2 = *q;
-  polling_island* next_1 = NULL;
-  polling_island* next_2 = NULL;
+  polling_island* next_1 = nullptr;
+  polling_island* next_2 = nullptr;
 
   /* The algorithm is simple:
       - Go to the last polling islands in the linked lists *pi_1 and *pi_2 (and
@@ -607,13 +607,13 @@ static void polling_island_lock_pair(polling_island** p, polling_island** q) {
         release the locks and continue the process from the first step */
   while (true) {
     next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
-    while (next_1 != NULL) {
+    while (next_1 != nullptr) {
       pi_1 = next_1;
       next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
     }
 
     next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
-    while (next_2 != NULL) {
+    while (next_2 != nullptr) {
       pi_2 = next_2;
       next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
     }
@@ -633,7 +633,7 @@ static void polling_island_lock_pair(polling_island** p, polling_island** q) {
 
     next_1 = (polling_island*)gpr_atm_acq_load(&pi_1->merged_to);
     next_2 = (polling_island*)gpr_atm_acq_load(&pi_2->merged_to);
-    if (next_1 == NULL && next_2 == NULL) {
+    if (next_1 == nullptr && next_2 == nullptr) {
       break;
     }
 
@@ -725,7 +725,7 @@ static void polling_island_global_shutdown() {
  * alarm 'epoch'). This wakeup_fd gives us something to alert on when such a
  * case occurs. */
 
-static grpc_fd* fd_freelist = NULL;
+static grpc_fd* fd_freelist = nullptr;
 static gpr_mu fd_freelist_mu;
 
 #ifndef NDEBUG
@@ -797,7 +797,7 @@ static void fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
 static void fd_global_shutdown(void) {
   gpr_mu_lock(&fd_freelist_mu);
   gpr_mu_unlock(&fd_freelist_mu);
-  while (fd_freelist != NULL) {
+  while (fd_freelist != nullptr) {
     grpc_fd* fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
     gpr_mu_destroy(&fd->po.mu);
@@ -807,16 +807,16 @@ static void fd_global_shutdown(void) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name) {
-  grpc_fd* new_fd = NULL;
+  grpc_fd* new_fd = nullptr;
 
   gpr_mu_lock(&fd_freelist_mu);
-  if (fd_freelist != NULL) {
+  if (fd_freelist != nullptr) {
     new_fd = fd_freelist;
     fd_freelist = fd_freelist->freelist_next;
   }
   gpr_mu_unlock(&fd_freelist_mu);
 
-  if (new_fd == NULL) {
+  if (new_fd == nullptr) {
     new_fd = (grpc_fd*)gpr_malloc(sizeof(grpc_fd));
     gpr_mu_init(&new_fd->po.mu);
   }
@@ -825,7 +825,7 @@ static grpc_fd* fd_create(int fd, const char* name) {
    * is a newly created fd (or an fd we got from the freelist), no one else
    * would be holding a lock to it anyway. */
   gpr_mu_lock(&new_fd->po.mu);
-  new_fd->po.pi = NULL;
+  new_fd->po.pi = nullptr;
 #ifndef NDEBUG
   new_fd->po.obj_type = POLL_OBJ_FD;
 #endif
@@ -837,8 +837,8 @@ static grpc_fd* fd_create(int fd, const char* name) {
   new_fd->write_closure.Init();
   gpr_atm_no_barrier_store(&new_fd->read_notifier_pollset, (gpr_atm)NULL);
 
-  new_fd->freelist_next = NULL;
-  new_fd->on_done_closure = NULL;
+  new_fd->freelist_next = nullptr;
+  new_fd->on_done_closure = nullptr;
 
   gpr_mu_unlock(&new_fd->po.mu);
 
@@ -864,7 +864,7 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
                       grpc_closure* on_done, int* release_fd,
                       bool already_closed, const char* reason) {
   grpc_error* error = GRPC_ERROR_NONE;
-  polling_island* unref_pi = NULL;
+  polling_island* unref_pi = nullptr;
 
   gpr_mu_lock(&fd->po.mu);
   fd->on_done_closure = on_done;
@@ -881,18 +881,18 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
      - Unlock the latest polling island
      - Set fd->po.pi to NULL (but remove the ref on the polling island
        before doing this.) */
-  if (fd->po.pi != NULL) {
+  if (fd->po.pi != nullptr) {
     polling_island* pi_latest = polling_island_lock(fd->po.pi);
     polling_island_remove_fd_locked(pi_latest, fd, already_closed, &error);
     gpr_mu_unlock(&pi_latest->mu);
 
     unref_pi = fd->po.pi;
-    fd->po.pi = NULL;
+    fd->po.pi = nullptr;
   }
 
   /* If release_fd is not NULL, we should be relinquishing control of the file
      descriptor fd->fd (but we still own the grpc_fd structure). */
-  if (release_fd != NULL) {
+  if (release_fd != nullptr) {
     *release_fd = fd->fd;
   } else {
     close(fd->fd);
@@ -904,7 +904,7 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
 
   gpr_mu_unlock(&fd->po.mu);
   UNREF_BY(fd, 2, reason); /* Drop the reference */
-  if (unref_pi != NULL) {
+  if (unref_pi != nullptr) {
     /* Unref stale polling island here, outside the fd lock above.
        The polling island owns a workqueue which owns an fd, and unreffing
        inside the lock can cause an eventual lock loop that makes TSAN very
@@ -1009,7 +1009,7 @@ static grpc_pollset_worker* pop_front_worker(grpc_pollset* p) {
     remove_worker(p, w);
     return w;
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
@@ -1033,7 +1033,7 @@ static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
   GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
   const char* err_desc = "Kick Failure";
   grpc_pollset_worker* worker = specific_worker;
-  if (worker != NULL) {
+  if (worker != nullptr) {
     if (worker == GRPC_POLLSET_KICK_BROADCAST) {
       if (pollset_has_workers(p)) {
         GPR_TIMER_BEGIN("pollset_kick.broadcast", 0);
@@ -1063,7 +1063,7 @@ static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
 
     GPR_TIMER_MARK("kick_anonymous", 0);
     worker = pop_front_worker(p);
-    if (worker != NULL) {
+    if (worker != nullptr) {
       GPR_TIMER_MARK("finally_kick", 0);
       push_back_worker(p, worker);
       append_error(&error, pollset_worker_kick(worker), err_desc);
@@ -1081,7 +1081,7 @@ static grpc_error* pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
 static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   gpr_mu_init(&pollset->po.mu);
   *mu = &pollset->po.mu;
-  pollset->po.pi = NULL;
+  pollset->po.pi = nullptr;
 #ifndef NDEBUG
   pollset->po.obj_type = POLL_OBJ_POLLSET;
 #endif
@@ -1091,7 +1091,7 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
 
   pollset->shutting_down = false;
   pollset->finish_shutdown_called = false;
-  pollset->shutdown_done = NULL;
+  pollset->shutdown_done = nullptr;
 }
 
 static int poll_deadline_to_millis_timeout(grpc_exec_ctx* exec_ctx,
@@ -1126,10 +1126,10 @@ static void fd_become_writable(grpc_exec_ctx* exec_ctx, grpc_fd* fd) {
 static void pollset_release_polling_island(grpc_exec_ctx* exec_ctx,
                                            grpc_pollset* ps,
                                            const char* reason) {
-  if (ps->po.pi != NULL) {
+  if (ps->po.pi != nullptr) {
     PI_UNREF(exec_ctx, ps->po.pi, reason);
   }
-  ps->po.pi = NULL;
+  ps->po.pi = nullptr;
 }
 
 static void finish_shutdown_locked(grpc_exec_ctx* exec_ctx,
@@ -1181,7 +1181,7 @@ static void pollset_work_and_unlock(grpc_exec_ctx* exec_ctx,
   struct epoll_event ep_ev[GRPC_EPOLL_MAX_EVENTS];
   int epoll_fd = -1;
   int ep_rv;
-  polling_island* pi = NULL;
+  polling_island* pi = nullptr;
   char* err_msg;
   const char* err_desc = "pollset_work_and_unlock";
   GPR_TIMER_BEGIN("pollset_work_and_unlock", 0);
@@ -1196,9 +1196,9 @@ static void pollset_work_and_unlock(grpc_exec_ctx* exec_ctx,
      right-away from epoll_wait() and pick up the latest polling_island the next
      this function (i.e pollset_work_and_unlock()) is called */
 
-  if (pollset->po.pi == NULL) {
-    pollset->po.pi = polling_island_create(exec_ctx, NULL, error);
-    if (pollset->po.pi == NULL) {
+  if (pollset->po.pi == nullptr) {
+    pollset->po.pi = polling_island_create(exec_ctx, nullptr, error);
+    if (pollset->po.pi == nullptr) {
       GPR_TIMER_END("pollset_work_and_unlock", 0);
       return; /* Fatal error. We cannot continue */
     }
@@ -1280,10 +1280,10 @@ static void pollset_work_and_unlock(grpc_exec_ctx* exec_ctx,
     }
   }
 
-  g_current_thread_polling_island = NULL;
+  g_current_thread_polling_island = nullptr;
   gpr_atm_no_barrier_fetch_add(&pi->poller_count, -1);
 
-  GPR_ASSERT(pi != NULL);
+  GPR_ASSERT(pi != nullptr);
 
   /* Before leaving, release the extra ref we added to the polling island. It
      is important to use "pi" here (i.e our old copy of pollset->po.pi
@@ -1309,7 +1309,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
   sigset_t new_mask;
 
   grpc_pollset_worker worker;
-  worker.next = worker.prev = NULL;
+  worker.next = worker.prev = nullptr;
   worker.pt_id = pthread_self();
   gpr_atm_no_barrier_store(&worker.is_kicked, (gpr_atm)0);
 
@@ -1391,7 +1391,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
     gpr_mu_lock(&pollset->po.mu);
   }
 
-  if (worker_hdl) *worker_hdl = NULL;
+  if (worker_hdl) *worker_hdl = nullptr;
 
   gpr_tls_set(&g_current_thread_pollset, (intptr_t)0);
   gpr_tls_set(&g_current_thread_worker, (intptr_t)0);
@@ -1413,7 +1413,7 @@ static void add_poll_object(grpc_exec_ctx* exec_ctx, poll_obj* bag,
 #endif
 
   grpc_error* error = GRPC_ERROR_NONE;
-  polling_island* pi_new = NULL;
+  polling_island* pi_new = nullptr;
 
   gpr_mu_lock(&bag->mu);
   gpr_mu_lock(&item->mu);
@@ -1440,7 +1440,7 @@ retry:
 
   if (item->pi == bag->pi) {
     pi_new = item->pi;
-    if (pi_new == NULL) {
+    if (pi_new == nullptr) {
       /* GPR_ASSERT(item->pi == bag->pi == NULL) */
 
       /* If we are adding an fd to a bag (i.e pollset or pollset_set), then
@@ -1460,7 +1460,7 @@ retry:
         /* Need to reverify any assumptions made between the initial lock and
            getting to this branch: if they've changed, we need to throw away our
            work and figure things out again. */
-        if (item->pi != NULL) {
+        if (item->pi != nullptr) {
           GRPC_POLLING_TRACE(
               "add_poll_object: Raced creating new polling island. pi_new: %p "
               "(fd: %d, %s: %p)",
@@ -1477,7 +1477,7 @@ retry:
           goto retry;
         }
       } else {
-        pi_new = polling_island_create(exec_ctx, NULL, &error);
+        pi_new = polling_island_create(exec_ctx, nullptr, &error);
       }
 
       GRPC_POLLING_TRACE(
@@ -1490,7 +1490,7 @@ retry:
           "add_poll_object: Same polling island. pi: %p (%s, %s)",
           (void*)pi_new, poll_obj_string(item_type), poll_obj_string(bag_type));
     }
-  } else if (item->pi == NULL) {
+  } else if (item->pi == nullptr) {
     /* GPR_ASSERT(bag->pi != NULL) */
     /* Make pi_new point to latest pi*/
     pi_new = polling_island_lock(bag->pi);
@@ -1506,7 +1506,7 @@ retry:
         "bag(%s): %p)",
         (void*)pi_new, poll_obj_string(item_type), (void*)item,
         poll_obj_string(bag_type), (void*)bag);
-  } else if (bag->pi == NULL) {
+  } else if (bag->pi == nullptr) {
     /* GPR_ASSERT(item->pi != NULL) */
     /* Make pi_new to point to latest pi */
     pi_new = polling_island_lock(item->pi);
@@ -1530,7 +1530,7 @@ retry:
 
   if (item->pi != pi_new) {
     PI_ADD_REF(pi_new, poll_obj_string(item_type));
-    if (item->pi != NULL) {
+    if (item->pi != nullptr) {
       PI_UNREF(exec_ctx, item->pi, poll_obj_string(item_type));
     }
     item->pi = pi_new;
@@ -1538,7 +1538,7 @@ retry:
 
   if (bag->pi != pi_new) {
     PI_ADD_REF(pi_new, poll_obj_string(bag_type));
-    if (bag->pi != NULL) {
+    if (bag->pi != nullptr) {
       PI_UNREF(exec_ctx, bag->pi, poll_obj_string(bag_type));
     }
     bag->pi = pi_new;
@@ -1564,7 +1564,7 @@ static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
 static grpc_pollset_set* pollset_set_create(void) {
   grpc_pollset_set* pss = (grpc_pollset_set*)gpr_malloc(sizeof(*pss));
   gpr_mu_init(&pss->po.mu);
-  pss->po.pi = NULL;
+  pss->po.pi = nullptr;
 #ifndef NDEBUG
   pss->po.obj_type = POLL_OBJ_POLLSET_SET;
 #endif
@@ -1575,7 +1575,7 @@ static void pollset_set_destroy(grpc_exec_ctx* exec_ctx,
                                 grpc_pollset_set* pss) {
   gpr_mu_destroy(&pss->po.mu);
 
-  if (pss->po.pi != NULL) {
+  if (pss->po.pi != nullptr) {
     PI_UNREF(exec_ctx, pss->po.pi, "pss_destroy");
   }
 
@@ -1711,34 +1711,39 @@ const grpc_event_engine_vtable* grpc_init_epollsig_linux(
     bool explicit_request) {
   /* If use of signals is disabled, we cannot use epoll engine*/
   if (is_grpc_wakeup_signal_initialized && grpc_wakeup_signal < 0) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping epollsig because use of signals is disabled.");
+    return nullptr;
   }
 
   if (!grpc_has_wakeup_fd()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping epollsig because of no wakeup fd.");
+    return nullptr;
   }
 
   if (!is_epoll_available()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping epollsig because epoll is unavailable.");
+    return nullptr;
   }
 
   if (!is_grpc_wakeup_signal_initialized) {
     if (explicit_request) {
       grpc_use_signal(SIGRTMIN + 6);
     } else {
-      return NULL;
+      gpr_log(GPR_ERROR,
+              "Skipping epollsig because uninitialized wakeup signal.");
+      return nullptr;
     }
   }
 
   fd_global_init();
 
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
-    return NULL;
+    return nullptr;
   }
 
   if (!GRPC_LOG_IF_ERROR("polling_island_global_init",
                          polling_island_global_init())) {
-    return NULL;
+    return nullptr;
   }
 
   return &vtable;
@@ -1751,6 +1756,8 @@ const grpc_event_engine_vtable* grpc_init_epollsig_linux(
  * NULL */
 const grpc_event_engine_vtable* grpc_init_epollsig_linux(
     bool explicit_request) {
+  gpr_log(GPR_ERROR,
+          "Skipping epollsig becuase GRPC_LINUX_EPOLL is not defined.");
   return NULL;
 }
 #endif /* defined(GRPC_POSIX_SOCKET) */

src/core/lib/iomgr/ev_poll_posix.cc

@@ -335,11 +335,11 @@ static grpc_fd* fd_create(int fd, const char* name) {
   r->fd = fd;
   r->inactive_watcher_root.next = r->inactive_watcher_root.prev =
       &r->inactive_watcher_root;
-  r->read_watcher = r->write_watcher = NULL;
-  r->on_done_closure = NULL;
+  r->read_watcher = r->write_watcher = nullptr;
+  r->on_done_closure = nullptr;
   r->closed = 0;
   r->released = 0;
-  r->read_notifier_pollset = NULL;
+  r->read_notifier_pollset = nullptr;
 
   char* name2;
   gpr_asprintf(&name2, "%s fd=%d", name, fd);
@@ -355,7 +355,7 @@ static bool fd_is_orphaned(grpc_fd* fd) {
 /* Return the read-notifier pollset */
 static grpc_pollset* fd_get_read_notifier_pollset(grpc_exec_ctx* exec_ctx,
                                                   grpc_fd* fd) {
-  grpc_pollset* notifier = NULL;
+  grpc_pollset* notifier = nullptr;
 
   gpr_mu_lock(&fd->mu);
   notifier = fd->read_notifier_pollset;
@@ -401,7 +401,7 @@ static void wake_all_watchers_locked(grpc_exec_ctx* exec_ctx, grpc_fd* fd) {
 }
 
 static int has_watchers(grpc_fd* fd) {
-  return fd->read_watcher != NULL || fd->write_watcher != NULL ||
+  return fd->read_watcher != nullptr || fd->write_watcher != nullptr ||
          fd->inactive_watcher_root.next != &fd->inactive_watcher_root;
 }
 
@@ -425,8 +425,8 @@ static void fd_orphan(grpc_exec_ctx* exec_ctx, grpc_fd* fd,
                       grpc_closure* on_done, int* release_fd,
                       bool already_closed, const char* reason) {
   fd->on_done_closure = on_done;
-  fd->released = release_fd != NULL;
-  if (release_fd != NULL) {
+  fd->released = release_fd != nullptr;
+  if (release_fd != nullptr) {
     *release_fd = fd->fd;
     fd->released = true;
   } else if (already_closed) {
@@ -565,9 +565,9 @@ static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
 
   /* if we are shutdown, then don't add to the watcher set */
   if (fd->shutdown) {
-    watcher->fd = NULL;
-    watcher->pollset = NULL;
-    watcher->worker = NULL;
+    watcher->fd = nullptr;
+    watcher->pollset = nullptr;
+    watcher->worker = nullptr;
     gpr_mu_unlock(&fd->mu);
     GRPC_FD_UNREF(fd, "poll");
     return 0;
@@ -576,7 +576,7 @@ static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
   /* if there is nobody polling for read, but we need to, then start doing so */
   cur = fd->read_closure;
   requested = cur != CLOSURE_READY;
-  if (read_mask && fd->read_watcher == NULL && requested) {
+  if (read_mask && fd->read_watcher == nullptr && requested) {
     fd->read_watcher = watcher;
     mask |= read_mask;
   }
@@ -584,12 +584,12 @@ static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
    */
   cur = fd->write_closure;
   requested = cur != CLOSURE_READY;
-  if (write_mask && fd->write_watcher == NULL && requested) {
+  if (write_mask && fd->write_watcher == nullptr && requested) {
     fd->write_watcher = watcher;
     mask |= write_mask;
   }
   /* if not polling, remember this watcher in case we need someone to later */
-  if (mask == 0 && worker != NULL) {
+  if (mask == 0 && worker != nullptr) {
     watcher->next = &fd->inactive_watcher_root;
     watcher->prev = watcher->next->prev;
     watcher->next->prev = watcher->prev->next = watcher;
@@ -609,7 +609,7 @@ static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* watcher,
   int kick = 0;
   grpc_fd* fd = watcher->fd;
 
-  if (fd == NULL) {
+  if (fd == nullptr) {
     return;
   }
 
@@ -621,7 +621,7 @@ static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* watcher,
     if (!got_read) {
       kick = 1;
     }
-    fd->read_watcher = NULL;
+    fd->read_watcher = nullptr;
   }
   if (watcher == fd->write_watcher) {
     /* remove write watcher, kick if we still need a write */
@@ -629,9 +629,9 @@ static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* watcher,
     if (!got_write) {
       kick = 1;
     }
-    fd->write_watcher = NULL;
+    fd->write_watcher = nullptr;
   }
-  if (!was_polling && watcher->worker != NULL) {
+  if (!was_polling && watcher->worker != nullptr) {
     /* remove from inactive list */
     watcher->next->prev = watcher->prev;
     watcher->prev->next = watcher->next;
@@ -640,7 +640,7 @@ static void fd_end_poll(grpc_exec_ctx* exec_ctx, grpc_fd_watcher* watcher,
     if (set_ready_locked(exec_ctx, fd, &fd->read_closure)) {
       kick = 1;
     }
-    if (read_notifier_pollset != NULL) {
+    if (read_notifier_pollset != nullptr) {
       set_read_notifier_pollset_locked(exec_ctx, fd, read_notifier_pollset);
     }
   }
@@ -690,7 +690,7 @@ static grpc_pollset_worker* pop_front_worker(grpc_pollset* p) {
     remove_worker(p, w);
     return w;
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
@@ -722,7 +722,7 @@ static grpc_error* pollset_kick_ext(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
   GRPC_STATS_INC_POLLSET_KICK(exec_ctx);
 
   /* pollset->mu already held */
-  if (specific_worker != NULL) {
+  if (specific_worker != nullptr) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
       GPR_TIMER_BEGIN("pollset_kick_ext.broadcast", 0);
       GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
@@ -756,7 +756,7 @@ static grpc_error* pollset_kick_ext(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
     GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
     GPR_TIMER_MARK("kick_anonymous", 0);
     specific_worker = pop_front_worker(p);
-    if (specific_worker != NULL) {
+    if (specific_worker != nullptr) {
       if (gpr_tls_get(&g_current_thread_worker) == (intptr_t)specific_worker) {
         GPR_TIMER_MARK("kick_anonymous_not_self", 0);
         push_back_worker(p, specific_worker);
@@ -765,10 +765,10 @@ static grpc_error* pollset_kick_ext(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
             gpr_tls_get(&g_current_thread_worker) ==
                 (intptr_t)specific_worker) {
           push_back_worker(p, specific_worker);
-          specific_worker = NULL;
+          specific_worker = nullptr;
         }
       }
-      if (specific_worker != NULL) {
+      if (specific_worker != nullptr) {
         GPR_TIMER_MARK("finally_kick", 0);
         push_back_worker(p, specific_worker);
         kick_append_error(
@@ -812,12 +812,12 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   pollset->shutting_down = 0;
   pollset->called_shutdown = 0;
   pollset->kicked_without_pollers = 0;
-  pollset->idle_jobs.head = pollset->idle_jobs.tail = NULL;
-  pollset->local_wakeup_cache = NULL;
+  pollset->idle_jobs.head = pollset->idle_jobs.tail = nullptr;
+  pollset->local_wakeup_cache = nullptr;
   pollset->kicked_without_pollers = 0;
   pollset->fd_count = 0;
   pollset->fd_capacity = 0;
-  pollset->fds = NULL;
+  pollset->fds = nullptr;
   pollset->pollset_set_count = 0;
 }
 
@@ -850,7 +850,7 @@ static void pollset_add_fd(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
   }
   pollset->fds[pollset->fd_count++] = fd;
   GRPC_FD_REF(fd, "multipoller");
-  pollset_kick(exec_ctx, pollset, NULL);
+  pollset_kick(exec_ctx, pollset, nullptr);
 exit:
   gpr_mu_unlock(&pollset->mu);
 }
@@ -892,9 +892,9 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
   int keep_polling = 0;
   GPR_TIMER_BEGIN("pollset_work", 0);
   /* this must happen before we (potentially) drop pollset->mu */
-  worker.next = worker.prev = NULL;
+  worker.next = worker.prev = nullptr;
   worker.reevaluate_polling_on_wakeup = 0;
-  if (pollset->local_wakeup_cache != NULL) {
+  if (pollset->local_wakeup_cache != nullptr) {
     worker.wakeup_fd = pollset->local_wakeup_cache;
     pollset->local_wakeup_cache = worker.wakeup_fd->next;
   } else {
@@ -1002,8 +1002,8 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
         }
 
         for (i = 1; i < pfd_count; i++) {
-          if (watchers[i].fd == NULL) {
-            fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          if (watchers[i].fd == nullptr) {
+            fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
           } else {
             // Wake up all the file descriptors, if we have an invalid one
             // we can identify it on the next pollset_work()
@@ -1012,7 +1012,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
         }
       } else if (r == 0) {
         for (i = 1; i < pfd_count; i++) {
-          fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
         }
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
@@ -1023,8 +1023,8 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
               &error, grpc_wakeup_fd_consume_wakeup(&worker.wakeup_fd->fd));
         }
         for (i = 1; i < pfd_count; i++) {
-          if (watchers[i].fd == NULL) {
-            fd_end_poll(exec_ctx, &watchers[i], 0, 0, NULL);
+          if (watchers[i].fd == nullptr) {
+            fd_end_poll(exec_ctx, &watchers[i], 0, 0, nullptr);
           } else {
             if (GRPC_TRACER_ON(grpc_polling_trace)) {
               gpr_log(GPR_DEBUG, "%p got_event: %d r:%d w:%d [%d]", pollset,
@@ -1083,7 +1083,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
   /* check shutdown conditions */
   if (pollset->shutting_down) {
     if (pollset_has_workers(pollset)) {
-      pollset_kick(exec_ctx, pollset, NULL);
+      pollset_kick(exec_ctx, pollset, nullptr);
     } else if (!pollset->called_shutdown && !pollset_has_observers(pollset)) {
       pollset->called_shutdown = 1;
       gpr_mu_unlock(&pollset->mu);
@@ -1101,7 +1101,7 @@ static grpc_error* pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
       gpr_mu_lock(&pollset->mu);
     }
   }
-  if (worker_hdl) *worker_hdl = NULL;
+  if (worker_hdl) *worker_hdl = nullptr;
   GPR_TIMER_END("pollset_work", 0);
   GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
   return error;
@@ -1319,7 +1319,7 @@ static void cache_insert_locked(poll_args* args) {
     poll_cache.active_pollers[key]->prev = args;
   }
   args->next = poll_cache.active_pollers[key];
-  args->prev = NULL;
+  args->prev = nullptr;
   poll_cache.active_pollers[key] = args;
   poll_cache.count++;
 }
@@ -1327,7 +1327,7 @@ static void cache_insert_locked(poll_args* args) {
 static void init_result(poll_args* pargs) {
   pargs->result = (poll_result*)gpr_malloc(sizeof(poll_result));
   gpr_ref_init(&pargs->result->refcount, 1);
-  pargs->result->watchers = NULL;
+  pargs->result->watchers = nullptr;
   pargs->result->watchcount = 0;
   pargs->result->fds =
       (struct pollfd*)gpr_malloc(sizeof(struct pollfd) * pargs->nfds);
@@ -1358,12 +1358,12 @@ static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
     poll_args* pargs = poll_cache.free_pollers;
     poll_cache.free_pollers = pargs->next;
     if (poll_cache.free_pollers) {
-      poll_cache.free_pollers->prev = NULL;
+      poll_cache.free_pollers->prev = nullptr;
     }
     pargs->fds = fds;
     pargs->nfds = count;
-    pargs->next = NULL;
-    pargs->prev = NULL;
+    pargs->next = nullptr;
+    pargs->prev = nullptr;
     init_result(pargs);
     cache_poller_locked(pargs);
     return pargs;
@@ -1373,8 +1373,8 @@ static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) {
   gpr_cv_init(&pargs->trigger);
   pargs->fds = fds;
   pargs->nfds = count;
-  pargs->next = NULL;
-  pargs->prev = NULL;
+  pargs->next = nullptr;
+  pargs->prev = nullptr;
   pargs->trigger_set = 0;
   init_result(pargs);
   cache_poller_locked(pargs);
@@ -1405,7 +1405,7 @@ static void cache_delete_locked(poll_args* args) {
   if (poll_cache.free_pollers) {
     poll_cache.free_pollers->prev = args;
   }
-  args->prev = NULL;
+  args->prev = nullptr;
   args->next = poll_cache.free_pollers;
   gpr_free(args->fds);
   poll_cache.free_pollers = args;
@@ -1419,11 +1419,11 @@ static void cache_poller_locked(poll_args* args) {
     poll_cache.active_pollers =
         (poll_args**)gpr_malloc(sizeof(void*) * poll_cache.size);
     for (unsigned int i = 0; i < poll_cache.size; i++) {
-      poll_cache.active_pollers[i] = NULL;
+      poll_cache.active_pollers[i] = nullptr;
     }
     for (unsigned int i = 0; i < poll_cache.size / 2; i++) {
       poll_args* curr = old_active_pollers[i];
-      poll_args* next = NULL;
+      poll_args* next = nullptr;
       while (curr) {
         next = curr->next;
         cache_insert_locked(curr);
@@ -1520,10 +1520,10 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
   cv_node* pollcv;
   int skip_poll = 0;
   nfds_t nsockfds = 0;
-  poll_result* result = NULL;
+  poll_result* result = nullptr;
   gpr_mu_lock(&g_cvfds.mu);
   pollcv = (cv_node*)gpr_malloc(sizeof(cv_node));
-  pollcv->next = NULL;
+  pollcv->next = nullptr;
   gpr_cv pollcv_cv;
   gpr_cv_init(&pollcv_cv);
   pollcv->cv = &pollcv_cv;
@@ -1534,7 +1534,7 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
     if (fds[i].fd < 0 && (fds[i].events & POLLIN)) {
       idx = GRPC_FD_TO_IDX(fds[i].fd);
       fd_cvs[i].cv = &pollcv_cv;
-      fd_cvs[i].prev = NULL;
+      fd_cvs[i].prev = nullptr;
       fd_cvs[i].next = g_cvfds.cvfds[idx].cvs;
       if (g_cvfds.cvfds[idx].cvs) {
         g_cvfds.cvfds[idx].cvs->prev = &(fd_cvs[i]);
@@ -1573,7 +1573,7 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
     poll_args* pargs = get_poller_locked(pollfds, nsockfds);
     result = pargs->result;
     pollcv->next = result->watchers;
-    pollcv->prev = NULL;
+    pollcv->prev = nullptr;
     if (result->watchers) {
       result->watchers->prev = pollcv;
     }
@@ -1624,11 +1624,11 @@ static void global_cv_fd_table_init() {
   gpr_ref_init(&g_cvfds.pollcount, 1);
   g_cvfds.size = CV_DEFAULT_TABLE_SIZE;
   g_cvfds.cvfds = (fd_node*)gpr_malloc(sizeof(fd_node) * CV_DEFAULT_TABLE_SIZE);
-  g_cvfds.free_fds = NULL;
+  g_cvfds.free_fds = nullptr;
   thread_grace = gpr_time_from_millis(POLLCV_THREAD_GRACE_MS, GPR_TIMESPAN);
   for (int i = 0; i < CV_DEFAULT_TABLE_SIZE; i++) {
     g_cvfds.cvfds[i].is_set = 0;
-    g_cvfds.cvfds[i].cvs = NULL;
+    g_cvfds.cvfds[i].cvs = nullptr;
     g_cvfds.cvfds[i].next_free = g_cvfds.free_fds;
     g_cvfds.free_fds = &g_cvfds.cvfds[i];
   }
@@ -1639,10 +1639,10 @@ static void global_cv_fd_table_init() {
   // Initialize the cache
   poll_cache.size = 32;
   poll_cache.count = 0;
-  poll_cache.free_pollers = NULL;
+  poll_cache.free_pollers = nullptr;
   poll_cache.active_pollers = (poll_args**)gpr_malloc(sizeof(void*) * 32);
   for (unsigned int i = 0; i < poll_cache.size; i++) {
-    poll_cache.active_pollers[i] = NULL;
+    poll_cache.active_pollers[i] = nullptr;
   }
 
   gpr_mu_unlock(&g_cvfds.mu);
@@ -1712,10 +1712,11 @@ static const grpc_event_engine_vtable vtable = {
 
 const grpc_event_engine_vtable* grpc_init_poll_posix(bool explicit_request) {
   if (!grpc_has_wakeup_fd()) {
-    return NULL;
+    gpr_log(GPR_ERROR, "Skipping poll because of no wakeup fd.");
+    return nullptr;
   }
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
-    return NULL;
+    return nullptr;
   }
   return &vtable;
 }
@@ -1726,7 +1727,7 @@ const grpc_event_engine_vtable* grpc_init_poll_cv_posix(bool explicit_request) {
   if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {
     global_cv_fd_table_shutdown();
     grpc_enable_cv_wakeup_fds(0);
-    return NULL;
+    return nullptr;
   }
   return &vtable;
 }

src/core/lib/iomgr/ev_posix.cc

@@ -51,7 +51,7 @@ grpc_poll_function_type grpc_poll_function = poll;
 grpc_wakeup_fd grpc_global_wakeup_fd;
 
 static const grpc_event_engine_vtable* g_event_engine;
-static const char* g_poll_strategy_name = NULL;
+static const char* g_poll_strategy_name = nullptr;
 
 typedef const grpc_event_engine_vtable* (*event_engine_factory_fn)(
     bool explicit_request);
@@ -114,7 +114,7 @@ static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
 
 static void split(const char* s, char*** ss, size_t* ns) {
   const char* c = strchr(s, ',');
-  if (c == NULL) {
+  if (c == nullptr) {
     add(s, s + strlen(s), ss, ns);
   } else {
     add(s, c, ss, ns);
@@ -156,15 +156,15 @@ void grpc_event_engine_init(void) {
   grpc_register_tracer(&grpc_polling_trace);
 
   char* s = gpr_getenv("GRPC_POLL_STRATEGY");
-  if (s == NULL) {
+  if (s == nullptr) {
     s = gpr_strdup("all");
   }
 
-  char** strings = NULL;
+  char** strings = nullptr;
   size_t nstrings = 0;
   split(s, &strings, &nstrings);
 
-  for (size_t i = 0; g_event_engine == NULL && i < nstrings; i++) {
+  for (size_t i = 0; g_event_engine == nullptr && i < nstrings; i++) {
     try_engine(strings[i]);
   }
 
@@ -172,17 +172,17 @@ void grpc_event_engine_init(void) {
     gpr_free(strings[i]);
   }
   gpr_free(strings);
-  gpr_free(s);
 
-  if (g_event_engine == NULL) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized");
+  if (g_event_engine == nullptr) {
+    gpr_log(GPR_ERROR, "No event engine could be initialized from %s", s);
     abort();
   }
+  gpr_free(s);
 }
 
 void grpc_event_engine_shutdown(void) {
   g_event_engine->shutdown_engine();
-  g_event_engine = NULL;
+  g_event_engine = nullptr;
 }
 
 grpc_fd* grpc_fd_create(int fd, const char* name) {