Remove unused parameter warning (3 of 20)

test/core/bad_client/tests/server_registered_method.cc

@@ -67,7 +67,7 @@ static void verifier_succeeds(grpc_server* server, grpc_completion_queue* cq,
 }
 
 static void verifier_fails(grpc_server* server, grpc_completion_queue* cq,
-                           void* registered_method) {
+                           void* /*registered_method*/) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
                    cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)

test/core/bad_client/tests/simple_request.cc

@@ -88,7 +88,7 @@
 static void* tag(intptr_t t) { return (void*)t; }
 
 static void verifier(grpc_server* server, grpc_completion_queue* cq,
-                     void* registered_method) {
+                     void* /*registered_method*/) {
   grpc_call_error error;
   grpc_call* s;
   grpc_call_details call_details;
@@ -114,7 +114,7 @@ static void verifier(grpc_server* server, grpc_completion_queue* cq,
 }
 
 static void failure_verifier(grpc_server* server, grpc_completion_queue* cq,
-                             void* registered_method) {
+                             void* /*registered_method*/) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
                    cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)

test/core/bad_client/tests/unknown_frame.cc

@@ -25,7 +25,7 @@
 #include "test/core/bad_client/bad_client.h"
 
 static void verifier(grpc_server* server, grpc_completion_queue* cq,
-                     void* registered_method) {
+                     void* /*registered_method*/) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
                    cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)

test/core/bad_client/tests/window_overflow.cc

@@ -43,7 +43,7 @@
   "\x10\x0auser-agent\"bad-client grpc-c/0.12.0.0 (linux)"
 
 static void verifier(grpc_server* server, grpc_completion_queue* cq,
-                     void* registered_method) {
+                     void* /*registered_method*/) {
   while (grpc_server_has_open_connections(server)) {
     GPR_ASSERT(grpc_completion_queue_next(
                    cq, grpc_timeout_milliseconds_to_deadline(20), nullptr)

test/core/channel/channel_args_test.cc

@@ -100,7 +100,7 @@ static void test_channel_create_with_args(void) {
 
 grpc_channel_args* mutate_channel_args(const char* target,
                                        grpc_channel_args* old_args,
-                                       grpc_channel_stack_type type) {
+                                       grpc_channel_stack_type /*type*/) {
   GPR_ASSERT(old_args != nullptr);
   GPR_ASSERT(grpc_channel_args_find(old_args, "arg_int")->value.integer == 0);
   GPR_ASSERT(strcmp(grpc_channel_args_find(old_args, "arg_str")->value.string,

test/core/channel/channel_stack_builder_test.cc

@@ -29,26 +29,26 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "test/core/util/test_config.h"
 
-static grpc_error* channel_init_func(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* channel_init_func(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* call_init_func(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* call_init_func(grpc_call_element* /*elem*/,
+                                  const grpc_call_element_args* /*args*/) {
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_channel_element* elem) {}
+static void channel_destroy_func(grpc_channel_element* /*elem*/) {}
 
-static void call_destroy_func(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {}
+static void call_destroy_func(grpc_call_element* /*elem*/,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {}
 
 bool g_replacement_fn_called = false;
 bool g_original_fn_called = false;
-void set_arg_once_fn(grpc_channel_stack* channel_stack,
-                     grpc_channel_element* elem, void* arg) {
+void set_arg_once_fn(grpc_channel_stack* /*channel_stack*/,
+                     grpc_channel_element* /*elem*/, void* arg) {
   bool* called = static_cast<bool*>(arg);
   // Make sure this function is only called once per arg.
   GPR_ASSERT(*called == false);

test/core/channel/channel_stack_test.cc

@@ -40,35 +40,36 @@ static grpc_error* channel_init_func(grpc_channel_element* elem,
 }
 
 static grpc_error* call_init_func(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+                                  const grpc_call_element_args* /*args*/) {
   ++*static_cast<int*>(elem->channel_data);
   *static_cast<int*>(elem->call_data) = 0;
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_channel_element* elem) {}
+static void channel_destroy_func(grpc_channel_element* /*elem*/) {}
 
 static void call_destroy_func(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {
   ++*static_cast<int*>(elem->channel_data);
 }
 
 static void call_func(grpc_call_element* elem,
-                      grpc_transport_stream_op_batch* op) {
+                      grpc_transport_stream_op_batch* /*op*/) {
   ++*static_cast<int*>(elem->call_data);
 }
 
-static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) {
+static void channel_func(grpc_channel_element* elem,
+                         grpc_transport_op* /*op*/) {
   ++*static_cast<int*>(elem->channel_data);
 }
 
-static void free_channel(void* arg, grpc_error* error) {
+static void free_channel(void* arg, grpc_error* /*error*/) {
   grpc_channel_stack_destroy(static_cast<grpc_channel_stack*>(arg));
   gpr_free(arg);
 }
 
-static void free_call(void* arg, grpc_error* error) {
+static void free_call(void* arg, grpc_error* /*error*/) {
   grpc_call_stack_destroy(static_cast<grpc_call_stack*>(arg), nullptr, nullptr);
   gpr_free(arg);
 }

test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc

@@ -35,8 +35,8 @@ static gpr_mu g_mu;
 static bool g_fail_resolution = true;
 static grpc_combiner* g_combiner;
 
-static void my_resolve_address(const char* addr, const char* default_port,
-                               grpc_pollset_set* interested_parties,
+static void my_resolve_address(const char* addr, const char* /*default_port*/,
+                               grpc_pollset_set* /*interested_parties*/,
                                grpc_closure* on_done,
                                grpc_resolved_addresses** addrs) {
   gpr_mu_lock(&g_mu);
@@ -61,11 +61,12 @@ static grpc_address_resolver_vtable test_resolver = {my_resolve_address,
                                                      nullptr};
 
 static grpc_ares_request* my_dns_lookup_ares_locked(
-    const char* dns_server, const char* addr, const char* default_port,
-    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    const char* /*dns_server*/, const char* addr,
+    const char* /*default_port*/, grpc_pollset_set* /*interested_parties*/,
+    grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
-    bool check_grpclb, char** service_config_json, int query_timeout_ms,
-    grpc_combiner* combiner) {
+    bool /*check_grpclb*/, char** /*service_config_json*/,
+    int /*query_timeout_ms*/, grpc_combiner* /*combiner*/) {
   gpr_mu_lock(&g_mu);
   GPR_ASSERT(0 == strcmp("test", addr));
   grpc_error* error = GRPC_ERROR_NONE;

test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc

@@ -60,11 +60,10 @@ static struct iomgr_args {
 
 // Wrapper around default resolve_address in order to count the number of
 // times we incur in a system-level name resolution.
-static void test_resolve_address_impl(const char* name,
-                                      const char* default_port,
-                                      grpc_pollset_set* interested_parties,
-                                      grpc_closure* on_done,
-                                      grpc_resolved_addresses** addrs) {
+static void test_resolve_address_impl(
+    const char* name, const char* default_port,
+    grpc_pollset_set* /*interested_parties*/, grpc_closure* on_done,
+    grpc_resolved_addresses** addrs) {
   default_resolve_address->resolve_address(
       name, default_port, g_iomgr_args.pollset_set, on_done, addrs);
   ++g_resolution_count;
@@ -92,7 +91,7 @@ static grpc_address_resolver_vtable test_resolver = {
 
 static grpc_ares_request* test_dns_lookup_ares_locked(
     const char* dns_server, const char* name, const char* default_port,
-    grpc_pollset_set* interested_parties, grpc_closure* on_done,
+    grpc_pollset_set* /*interested_parties*/, grpc_closure* on_done,
     grpc_core::UniquePtr<grpc_core::ServerAddressList>* addresses,
     bool check_grpclb, char** service_config_json, int query_timeout_ms,
     grpc_combiner* combiner) {
@@ -121,7 +120,7 @@ static gpr_timespec test_deadline(void) {
   return grpc_timeout_seconds_to_deadline(100);
 }
 
-static void do_nothing(void* arg, grpc_error* error) {}
+static void do_nothing(void* /*arg*/, grpc_error* /*error*/) {}
 
 static void iomgr_args_init(iomgr_args* args) {
   gpr_event_init(&args->ev);
@@ -187,7 +186,7 @@ class ResultHandler : public grpc_core::Resolver::ResultHandler {
     state_ = state;
   }
 
-  void ReturnResult(grpc_core::Resolver::Result result) override {
+  void ReturnResult(grpc_core::Resolver::Result /*result*/) override {
     GPR_ASSERT(result_cb_ != nullptr);
     GPR_ASSERT(state_ != nullptr);
     ResultCallback cb = result_cb_;
@@ -271,7 +270,7 @@ static void on_first_resolution(OnResolutionCallbackArg* cb_arg) {
   gpr_mu_unlock(g_iomgr_args.mu);
 }
 
-static void start_test_under_combiner(void* arg, grpc_error* error) {
+static void start_test_under_combiner(void* arg, grpc_error* /*error*/) {
   OnResolutionCallbackArg* res_cb_arg =
       static_cast<OnResolutionCallbackArg*>(arg);
   res_cb_arg->result_handler = grpc_core::New<ResultHandler>();

test/core/client_channel/resolvers/dns_resolver_test.cc

@@ -31,8 +31,8 @@
 static grpc_combiner* g_combiner;
 
 class TestResultHandler : public grpc_core::Resolver::ResultHandler {
-  void ReturnResult(grpc_core::Resolver::Result result) override {}
-  void ReturnError(grpc_error* error) override {}
+  void ReturnResult(grpc_core::Resolver::Result /*result*/) override {}
+  void ReturnError(grpc_error* /*error*/) override {}
 };
 
 static void test_succeeds(grpc_core::ResolverFactory* factory,