Merge branch 'master' into combinernew

5 years ago · 3edeee7ce9
parent 22b343e4fb e8f78e7a5d
commit 3edeee7ce9
317 changed files with 37054 additions and 584 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -43,9 +43,6 @@
 [submodule "third_party/protoc-gen-validate"]
 	path = third_party/protoc-gen-validate
 	url = https://github.com/envoyproxy/protoc-gen-validate.git
-[submodule "third_party/upb"]
-	path = third_party/upb
-	url = https://github.com/protocolbuffers/upb.git
 [submodule "third_party/udpa"]
 	path = third_party/udpa
 	url = https://github.com/cncf/udpa.git
--- a/src/core/lib/iomgr/executor/threadpool.h
+++ b/src/core/lib/iomgr/executor/threadpool.h
@ -62,7 +62,7 @@ class ThreadPoolInterface {
 // NULL closure.
 class ThreadPoolWorker {
 public:
-  ThreadPoolWorker(const char* thd_name, ThreadPoolInterface* pool,
+  ThreadPoolWorker(const char* thd_name, ThreadPoolInterface* /*pool*/,
                   MPMCQueueInterface* queue, Thread::Options& options,
                   int index)
      : queue_(queue), thd_name_(thd_name), index_(index) {
--- a/src/cpp/client/secure_credentials.cc
+++ b/src/cpp/client/secure_credentials.cc
@ -382,7 +382,7 @@ std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(

 namespace grpc {
 namespace {
-void DeleteWrapper(void* wrapper, grpc_error* ignored) {
+void DeleteWrapper(void* wrapper, grpc_error* /*ignored*/) {
  MetadataCredentialsPluginWrapper* w =
      static_cast<MetadataCredentialsPluginWrapper*>(wrapper);
  delete w;
--- a/src/cpp/common/channel_filter.h
+++ b/src/cpp/common/channel_filter.h
@ -236,13 +236,13 @@ class ChannelData {
  // TODO(roth): Come up with a more C++-like API for the channel element.

  /// Initializes the channel data.
-  virtual grpc_error* Init(grpc_channel_element* elem,
-                           grpc_channel_element_args* args) {
+  virtual grpc_error* Init(grpc_channel_element* /*elem*/,
+                           grpc_channel_element_args* /*args*/) {
    return GRPC_ERROR_NONE;
  }

  // Called before destruction.
-  virtual void Destroy(grpc_channel_element* elem) {}
+  virtual void Destroy(grpc_channel_element* /*elem*/) {}

  virtual void StartTransportOp(grpc_channel_element* elem, TransportOp* op);

@ -259,15 +259,15 @@ class CallData {
  // TODO(roth): Come up with a more C++-like API for the call element.

  /// Initializes the call data.
-  virtual grpc_error* Init(grpc_call_element* elem,
-                           const grpc_call_element_args* args) {
+  virtual grpc_error* Init(grpc_call_element* /*elem*/,
+                           const grpc_call_element_args* /*args*/) {
    return GRPC_ERROR_NONE;
  }

  // Called before destruction.
-  virtual void Destroy(grpc_call_element* elem,
-                       const grpc_call_final_info* final_info,
-                       grpc_closure* then_call_closure) {}
+  virtual void Destroy(grpc_call_element* /*elem*/,
+                       const grpc_call_final_info* /*final_info*/,
+                       grpc_closure* /*then_call_closure*/) {}

  /// Starts a new stream operation.
  virtual void StartTransportStreamOpBatch(grpc_call_element* elem,
--- a/src/cpp/common/tls_credentials_options_util.cc
+++ b/src/cpp/common/tls_credentials_options_util.cc
@ -57,7 +57,7 @@ grpc_tls_key_materials_config* ConvertToCKeyMaterialsConfig(
 /** The C schedule and cancel functions for the credential reload config.
 * They populate a C credential reload arg with the result of a C++ credential
 * reload schedule/cancel API. **/
-int TlsCredentialReloadConfigCSchedule(void* config_user_data,
+int TlsCredentialReloadConfigCSchedule(void* /*config_user_data*/,
                                       grpc_tls_credential_reload_arg* arg) {
  if (arg == nullptr || arg->config == nullptr ||
      arg->config->context() == nullptr) {
@ -71,7 +71,7 @@ int TlsCredentialReloadConfigCSchedule(void* config_user_data,
  return schedule_result;
 }

-void TlsCredentialReloadConfigCCancel(void* config_user_data,
+void TlsCredentialReloadConfigCCancel(void* /*config_user_data*/,
                                      grpc_tls_credential_reload_arg* arg) {
  if (arg == nullptr || arg->config == nullptr ||
      arg->config->context() == nullptr) {
@ -101,7 +101,7 @@ void TlsCredentialReloadArgDestroyContext(void* context) {
 * config. They populate a C server authorization check arg with the result
 * of a C++ server authorization check schedule/cancel API. **/
 int TlsServerAuthorizationCheckConfigCSchedule(
-    void* config_user_data, grpc_tls_server_authorization_check_arg* arg) {
+    void* /*config_user_data*/, grpc_tls_server_authorization_check_arg* arg) {
  if (arg == nullptr || arg->config == nullptr ||
      arg->config->context() == nullptr) {
    gpr_log(GPR_ERROR,
@ -117,7 +117,7 @@ int TlsServerAuthorizationCheckConfigCSchedule(
 }

 void TlsServerAuthorizationCheckConfigCCancel(
-    void* config_user_data, grpc_tls_server_authorization_check_arg* arg) {
+    void* /*config_user_data*/, grpc_tls_server_authorization_check_arg* arg) {
  if (arg == nullptr || arg->config == nullptr ||
      arg->config->context() == nullptr) {
    gpr_log(GPR_ERROR,
--- a/src/cpp/ext/proto_server_reflection.cc
+++ b/src/cpp/ext/proto_server_reflection.cc
@ -97,7 +97,7 @@ void ProtoServerReflection::FillErrorResponse(const Status& status,
  error_response->set_error_message(status.error_message());
 }

-Status ProtoServerReflection::ListService(ServerContext* context,
+Status ProtoServerReflection::ListService(ServerContext* /*context*/,
                                          ListServiceResponse* response) {
  if (services_ == nullptr) {
    return Status(StatusCode::NOT_FOUND, "Services not found.");
@ -110,7 +110,7 @@ Status ProtoServerReflection::ListService(ServerContext* context,
 }

 Status ProtoServerReflection::GetFileByName(
-    ServerContext* context, const grpc::string& filename,
+    ServerContext* /*context*/, const grpc::string& filename,
    ServerReflectionResponse* response) {
  if (descriptor_pool_ == nullptr) {
    return Status::CANCELLED;
@ -127,7 +127,7 @@ Status ProtoServerReflection::GetFileByName(
 }

 Status ProtoServerReflection::GetFileContainingSymbol(
-    ServerContext* context, const grpc::string& symbol,
+    ServerContext* /*context*/, const grpc::string& symbol,
    ServerReflectionResponse* response) {
  if (descriptor_pool_ == nullptr) {
    return Status::CANCELLED;
@ -144,7 +144,7 @@ Status ProtoServerReflection::GetFileContainingSymbol(
 }

 Status ProtoServerReflection::GetFileContainingExtension(
-    ServerContext* context, const ExtensionRequest* request,
+    ServerContext* /*context*/, const ExtensionRequest* request,
    ServerReflectionResponse* response) {
  if (descriptor_pool_ == nullptr) {
    return Status::CANCELLED;
@ -168,7 +168,7 @@ Status ProtoServerReflection::GetFileContainingExtension(
 }

 Status ProtoServerReflection::GetAllExtensionNumbers(
-    ServerContext* context, const grpc::string& type,
+    ServerContext* /*context*/, const grpc::string& type,
    ExtensionNumberResponse* response) {
  if (descriptor_pool_ == nullptr) {
    return Status::CANCELLED;
--- a/src/cpp/ext/proto_server_reflection_plugin.cc
+++ b/src/cpp/ext/proto_server_reflection_plugin.cc
@ -41,8 +41,8 @@ void ProtoServerReflectionPlugin::Finish(grpc::ServerInitializer* si) {
  reflection_service_->SetServiceList(si->GetServiceList());
 }

-void ProtoServerReflectionPlugin::ChangeArguments(const grpc::string& name,
-                                                  void* value) {}
+void ProtoServerReflectionPlugin::ChangeArguments(const grpc::string& /*name*/,
+                                                  void* /*value*/) {}

 bool ProtoServerReflectionPlugin::has_sync_methods() const {
  if (reflection_service_) {
--- a/src/cpp/server/channelz/channelz_service.cc
+++ b/src/cpp/server/channelz/channelz_service.cc
@ -32,7 +32,8 @@ grpc::protobuf::util::Status ParseJson(const char* json_str,
 }

 Status ChannelzService::GetTopChannels(
-    ServerContext* unused, const channelz::v1::GetTopChannelsRequest* request,
+    ServerContext* /*unused*/,
+    const channelz::v1::GetTopChannelsRequest* request,
    channelz::v1::GetTopChannelsResponse* response) {
  char* json_str = grpc_channelz_get_top_channels(request->start_channel_id());
  if (json_str == nullptr) {
@ -48,7 +49,7 @@ Status ChannelzService::GetTopChannels(
 }

 Status ChannelzService::GetServers(
-    ServerContext* unused, const channelz::v1::GetServersRequest* request,
+    ServerContext* /*unused*/, const channelz::v1::GetServersRequest* request,
    channelz::v1::GetServersResponse* response) {
  char* json_str = grpc_channelz_get_servers(request->start_server_id());
  if (json_str == nullptr) {
@ -63,7 +64,7 @@ Status ChannelzService::GetServers(
  return Status::OK;
 }

-Status ChannelzService::GetServer(ServerContext* unused,
+Status ChannelzService::GetServer(ServerContext* /*unused*/,
                                  const channelz::v1::GetServerRequest* request,
                                  channelz::v1::GetServerResponse* response) {
  char* json_str = grpc_channelz_get_server(request->server_id());
@ -80,7 +81,8 @@ Status ChannelzService::GetServer(ServerContext* unused,
 }

 Status ChannelzService::GetServerSockets(
-    ServerContext* unused, const channelz::v1::GetServerSocketsRequest* request,
+    ServerContext* /*unused*/,
+    const channelz::v1::GetServerSocketsRequest* request,
    channelz::v1::GetServerSocketsResponse* response) {
  char* json_str = grpc_channelz_get_server_sockets(
      request->server_id(), request->start_socket_id(), request->max_results());
@ -97,7 +99,7 @@ Status ChannelzService::GetServerSockets(
 }

 Status ChannelzService::GetChannel(
-    ServerContext* unused, const channelz::v1::GetChannelRequest* request,
+    ServerContext* /*unused*/, const channelz::v1::GetChannelRequest* request,
    channelz::v1::GetChannelResponse* response) {
  char* json_str = grpc_channelz_get_channel(request->channel_id());
  if (json_str == nullptr) {
@ -112,7 +114,8 @@ Status ChannelzService::GetChannel(
 }

 Status ChannelzService::GetSubchannel(
-    ServerContext* unused, const channelz::v1::GetSubchannelRequest* request,
+    ServerContext* /*unused*/,
+    const channelz::v1::GetSubchannelRequest* request,
    channelz::v1::GetSubchannelResponse* response) {
  char* json_str = grpc_channelz_get_subchannel(request->subchannel_id());
  if (json_str == nullptr) {
@ -127,7 +130,7 @@ Status ChannelzService::GetSubchannel(
  return Status::OK;
 }

-Status ChannelzService::GetSocket(ServerContext* unused,
+Status ChannelzService::GetSocket(ServerContext* /*unused*/,
                                  const channelz::v1::GetSocketRequest* request,
                                  channelz::v1::GetSocketResponse* response) {
  char* json_str = grpc_channelz_get_socket(request->socket_id());
--- a/src/cpp/server/channelz/channelz_service_plugin.cc
+++ b/src/cpp/server/channelz/channelz_service_plugin.cc
@ -39,9 +39,10 @@ class ChannelzServicePlugin : public ::grpc::ServerBuilderPlugin {
    si->RegisterService(channelz_service_);
  }

-  void Finish(grpc::ServerInitializer* si) override {}
+  void Finish(grpc::ServerInitializer* /*si*/) override {}

-  void ChangeArguments(const grpc::string& name, void* value) override {}
+  void ChangeArguments(const grpc::string& /*name*/, void* /*value*/) override {
+  }

  bool has_sync_methods() const override {
    if (channelz_service_) {
--- a/src/cpp/server/health/default_health_check_service.h
+++ b/src/cpp/server/health/default_health_check_service.h
@ -120,8 +120,8 @@ class DefaultHealthCheckService final : public HealthCheckServiceInterface {
                       HealthCheckServiceImpl* service);

      // Not used for Check.
-      void SendHealth(std::shared_ptr<CallHandler> self,
-                      ServingStatus status) override {}
+      void SendHealth(std::shared_ptr<CallHandler> /*self*/,
+                      ServingStatus /*status*/) override {}

     private:
      // Called when we receive a call.
--- a/src/cpp/server/server_cc.cc
+++ b/src/cpp/server/server_cc.cc
@ -75,8 +75,8 @@ namespace {
 class DefaultGlobalCallbacks final : public Server::GlobalCallbacks {
 public:
  ~DefaultGlobalCallbacks() override {}
-  void PreSynchronousRequest(ServerContext* context) override {}
-  void PostSynchronousRequest(ServerContext* context) override {}
+  void PreSynchronousRequest(ServerContext* /*context*/) override {}
+  void PostSynchronousRequest(ServerContext* /*context*/) override {}
 };

 std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr;
@ -90,12 +90,12 @@ void InitGlobalCallbacks() {

 class ShutdownTag : public internal::CompletionQueueTag {
 public:
-  bool FinalizeResult(void** tag, bool* status) { return false; }
+  bool FinalizeResult(void** /*tag*/, bool* /*status*/) { return false; }
 };

 class DummyTag : public internal::CompletionQueueTag {
 public:
-  bool FinalizeResult(void** tag, bool* status) { return true; }
+  bool FinalizeResult(void** /*tag*/, bool* /*status*/) { return true; }
 };

 class UnimplementedAsyncRequestContext {
@ -187,7 +187,7 @@ void ServerInterface::BaseAsyncRequest::
  grpc_cq_begin_op(notification_cq_->cq(), this);
  grpc_cq_end_op(
      notification_cq_->cq(), this, GRPC_ERROR_NONE,
-      [](void* arg, grpc_cq_completion* completion) { delete completion; },
+      [](void* /*arg*/, grpc_cq_completion* completion) { delete completion; },
      nullptr, new grpc_cq_completion());
 }

@ -395,7 +395,7 @@ class Server::SyncRequest final : public grpc::internal::CompletionQueueTag {
    }
  }

-  bool FinalizeResult(void** tag, bool* status) override {
+  bool FinalizeResult(void** /*tag*/, bool* status) override {
    if (!*status) {
      grpc_completion_queue_destroy(cq_);
      cq_ = nullptr;
@ -785,13 +785,13 @@ class Server::CallbackRequest final : public Server::CallbackRequestBase {

 template <>
 bool Server::CallbackRequest<grpc::ServerContext>::FinalizeResult(
-    void** tag, bool* status) {
+    void** /*tag*/, bool* /*status*/) {
  return false;
 }

 template <>
 bool Server::CallbackRequest<grpc::GenericServerContext>::FinalizeResult(
-    void** tag, bool* status) {
+    void** /*tag*/, bool* status) {
  if (*status) {
    // TODO(yangg) remove the copy here
    ctx_.method_ = grpc::StringFromCopiedSlice(call_details_->method);
--- a/src/cpp/server/server_context.cc
+++ b/src/cpp/server/server_context.cc
@ -73,7 +73,7 @@ class ServerContext::CompletionOp final
  // This should always be arena allocated in the call, so override delete.
  // But this class is not trivially destructible, so must actually call delete
  // before allowing the arena to be freed
-  static void operator delete(void* ptr, std::size_t size) {
+  static void operator delete(void* /*ptr*/, std::size_t size) {
    assert(size == sizeof(CompletionOp));
  }

--- a/test/core/bad_client/bad_client.cc
+++ b/test/core/bad_client/bad_client.cc
@ -57,7 +57,7 @@ static void thd_func(void* arg) {
 }

 /* Sets the done_write event */
-static void set_done_write(void* arg, grpc_error* error) {
+static void set_done_write(void* arg, grpc_error* /*error*/) {
  gpr_event* done_write = static_cast<gpr_event*>(arg);
  gpr_event_set(done_write, (void*)1);
 }
@ -70,7 +70,7 @@ static void server_setup_transport(void* ts, grpc_transport* transport) {
 }

 /* Sets the read_done event */
-static void set_read_done(void* arg, grpc_error* error) {
+static void set_read_done(void* arg, grpc_error* /*error*/) {
  gpr_event* read_done = static_cast<gpr_event*>(arg);
  gpr_event_set(read_done, (void*)1);
 }
@ -252,7 +252,7 @@ void grpc_run_bad_client_test(
 }

 bool client_connection_preface_validator(grpc_slice_buffer* incoming,
-                                         void* arg) {
+                                         void* /*arg*/) {
  if (incoming->count < 1) {
    return false;
  }
@ -278,7 +278,7 @@ grpc_bad_client_arg connection_preface_arg = {
    client_connection_preface_validator, nullptr,
    CONNECTION_PREFACE_FROM_CLIENT, sizeof(CONNECTION_PREFACE_FROM_CLIENT) - 1};

-bool rst_stream_client_validator(grpc_slice_buffer* incoming, void* arg) {
+bool rst_stream_client_validator(grpc_slice_buffer* incoming, void* /*arg*/) {
  // Get last frame from incoming slice buffer.
  grpc_slice_buffer last_frame_buffer;
  grpc_slice_buffer_init(&last_frame_buffer);
@ -311,7 +311,7 @@ static void* tag(intptr_t t) { return (void*)t; }

 void server_verifier_request_call(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;
--- a/test/core/bad_client/tests/bad_streaming_id.cc
+++ b/test/core/bad_client/tests/bad_streaming_id.cc
@ -75,7 +75,7 @@
 namespace {

 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)
--- a/test/core/bad_client/tests/badreq.cc
+++ b/test/core/bad_client/tests/badreq.cc
@ -30,7 +30,7 @@
  "\x00\x00\x00\x04\x00\x00\x00\x00\x00" /* settings frame */

 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)
--- a/test/core/bad_client/tests/connection_prefix.cc
+++ b/test/core/bad_client/tests/connection_prefix.cc
@ -20,7 +20,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)
--- a/test/core/bad_client/tests/duplicate_header.cc
+++ b/test/core/bad_client/tests/duplicate_header.cc
@ -52,7 +52,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;
--- a/test/core/bad_client/tests/headers.cc
+++ b/test/core/bad_client/tests/headers.cc
@ -24,7 +24,7 @@
  "\x00\x00\x00\x04\x00\x00\x00\x00\x00"

 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)
--- a/test/core/bad_client/tests/initial_settings_frame.cc
+++ b/test/core/bad_client/tests/initial_settings_frame.cc
@ -23,7 +23,7 @@
 #define ONE_SETTING_HDR "\x00\x00\x06\x04\x00\x00\x00\x00\x00"

 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)
--- a/test/core/bad_client/tests/large_metadata.cc
+++ b/test/core/bad_client/tests/large_metadata.cc
@ -92,9 +92,9 @@

 static void* tag(intptr_t t) { return (void*)t; }

-static void server_verifier_sends_too_much_metadata(grpc_server* server,
-                                                    grpc_completion_queue* cq,
-                                                    void* registered_method) {
+static void server_verifier_sends_too_much_metadata(
+    grpc_server* server, grpc_completion_queue* cq,
+    void* /*registered_method*/) {
  grpc_call_error error;
  grpc_call* s;
  grpc_call_details call_details;
--- a/test/core/bad_client/tests/out_of_bounds.cc
+++ b/test/core/bad_client/tests/out_of_bounds.cc
@ -30,7 +30,7 @@
 namespace {

 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)
--- a/test/core/bad_client/tests/server_registered_method.cc
+++ b/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)
--- a/test/core/bad_client/tests/simple_request.cc
+++ b/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)
--- a/test/core/bad_client/tests/unknown_frame.cc
+++ b/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)
--- a/test/core/bad_client/tests/window_overflow.cc
+++ b/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)
--- a/test/core/channel/channel_args_test.cc
+++ b/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,
--- a/test/core/channel/channel_stack_builder_test.cc
+++ b/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);
--- a/test/core/channel/channel_stack_test.cc
+++ b/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);
 }
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
+++ b/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_core::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,11 @@ 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_core::Combiner* combiner) {
+    bool /*check_grpclb*/, char** /*service_config_json*/,
+    int /*query_timeout_ms*/, grpc_core::Combiner* /*combiner*/) {
  gpr_mu_lock(&g_mu);
  GPR_ASSERT(0 == strcmp("test", addr));
  grpc_error* error = GRPC_ERROR_NONE;
--- a/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc
+++ b/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc
@ -62,7 +62,7 @@ static struct iomgr_args {
 // 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_pollset_set* /*interested_parties*/,
                                      grpc_closure* on_done,
                                      grpc_resolved_addresses** addrs) {
  default_resolve_address->resolve_address(
@ -92,7 +92,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_core::Combiner* combiner) {
@ -121,7 +121,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 +187,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 +271,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>();
--- a/test/core/client_channel/resolvers/dns_resolver_test.cc
+++ b/test/core/client_channel/resolvers/dns_resolver_test.cc
@ -31,8 +31,8 @@
 static grpc_core::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,
--- a/test/core/client_channel/resolvers/fake_resolver_test.cc
+++ b/test/core/client_channel/resolvers/fake_resolver_test.cc
@ -55,7 +55,7 @@ class ResultHandler : public grpc_core::Resolver::ResultHandler {
    ev_ = nullptr;
  }

-  void ReturnError(grpc_error* error) override {}
+  void ReturnError(grpc_error* /*error*/) override {}

 private:
  grpc_core::Resolver::Result expected_;
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
@ -32,7 +32,7 @@ static grpc_core::Combiner* g_combiner;

 class ResultHandler : public grpc_core::Resolver::ResultHandler {
 public:
-  void ReturnResult(grpc_core::Resolver::Result result) override {}
+  void ReturnResult(grpc_core::Resolver::Result /*result*/) override {}

  void ReturnError(grpc_error* error) override { GRPC_ERROR_UNREF(error); }
 };
--- a/test/core/client_channel/service_config_test.cc
+++ b/test/core/client_channel/service_config_test.cc
@ -116,14 +116,14 @@ class TestParser2 : public ServiceConfig::Parser {
 class ErrorParser : public ServiceConfig::Parser {
 public:
  UniquePtr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
-      const grpc_json* json, grpc_error** error) override {
+      const grpc_json* /*json*/, grpc_error** error) override {
    GPR_DEBUG_ASSERT(error != nullptr);
    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(MethodError());
    return nullptr;
  }

  UniquePtr<ServiceConfig::ParsedConfig> ParseGlobalParams(
-      const grpc_json* json, grpc_error** error) override {
+      const grpc_json* /*json*/, grpc_error** error) override {
    GPR_DEBUG_ASSERT(error != nullptr);
    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(GlobalError());
    return nullptr;
--- a/test/core/compression/compression_test.cc
+++ b/test/core/compression/compression_test.cc
@ -335,7 +335,7 @@ static void test_channel_args_compression_algorithm_states(void) {
  grpc_channel_args_destroy(ch_args);
 }

-int main(int argc, char** argv) {
+int main(int /*argc*/, char** /*argv*/) {
  grpc_init();
  test_compression_algorithm_parse();
  test_compression_algorithm_name();
--- a/test/core/compression/stream_compression_test.cc
+++ b/test/core/compression/stream_compression_test.cc
@ -287,7 +287,7 @@ static void test_stream_compression_sync_flush() {
  grpc_slice_buffer_destroy(&sink);
 }

-int main(int argc, char** argv) {
+int main(int /*argc*/, char** /*argv*/) {
  grpc_init();
  test_stream_compression_simple_compress_decompress();
  test_stream_compression_simple_compress_decompress_with_output_size_constraint();
--- a/test/core/end2end/bad_server_response_test.cc
+++ b/test/core/end2end/bad_server_response_test.cc
@ -92,7 +92,7 @@ static grpc_closure on_write;

 static void* tag(intptr_t t) { return (void*)t; }

-static void done_write(void* arg, grpc_error* error) {
+static void done_write(void* /*arg*/, grpc_error* error) {
  GPR_ASSERT(error == GRPC_ERROR_NONE);

  gpr_atm_rel_store(&state.done_atm, 1);
@ -107,7 +107,7 @@ static void handle_write() {
  grpc_endpoint_write(state.tcp, &state.outgoing_buffer, &on_write, nullptr);
 }

-static void handle_read(void* arg, grpc_error* error) {
+static void handle_read(void* /*arg*/, grpc_error* error) {
  GPR_ASSERT(error == GRPC_ERROR_NONE);
  state.incoming_data_length += state.temp_incoming_buffer.length;

@ -132,7 +132,7 @@ static void handle_read(void* arg, grpc_error* error) {
 }

 static void on_connect(void* arg, grpc_endpoint* tcp,
-                       grpc_pollset* accepting_pollset,
+                       grpc_pollset* /*accepting_pollset*/,
                       grpc_tcp_server_acceptor* acceptor) {
  gpr_free(acceptor);
  test_tcp_server* server = static_cast<test_tcp_server*>(arg);
--- a/test/core/end2end/dualstack_socket_test.cc
+++ b/test/core/end2end/dualstack_socket_test.cc
@ -51,7 +51,7 @@ static void drain_cq(grpc_completion_queue* cq) {
  } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }

-static void do_nothing(void* ignored) {}
+static void do_nothing(void* /*ignored*/) {}

 static void log_resolved_addrs(const char* label, const char* hostname) {
  grpc_resolved_addresses* res = nullptr;
--- a/test/core/end2end/fixtures/h2_census.cc
+++ b/test/core/end2end/fixtures/h2_census.cc
@ -40,7 +40,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_compress.cc
+++ b/test/core/end2end/fixtures/h2_compress.cc
@ -47,7 +47,7 @@ struct fullstack_compression_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_compression(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_compression_fixture_data* ffd =
--- a/test/core/end2end/fixtures/h2_fakesec.cc
+++ b/test/core/end2end/fixtures/h2_fakesec.cc
@ -36,7 +36,7 @@ struct fullstack_secure_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
@ -51,8 +51,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
--- a/test/core/end2end/fixtures/h2_fd.cc
+++ b/test/core/end2end/fixtures/h2_fd.cc
@ -51,7 +51,7 @@ static void create_sockets(int sv[2]) {
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  sp_fixture_data* fixture_data =
      static_cast<sp_fixture_data*>(gpr_malloc(sizeof(*fixture_data)));

--- a/test/core/end2end/fixtures/h2_full+pipe.cc
+++ b/test/core/end2end/fixtures/h2_full+pipe.cc
@ -45,7 +45,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_full+trace.cc
+++ b/test/core/end2end/fixtures/h2_full+trace.cc
@ -45,7 +45,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_full+workarounds.cc
+++ b/test/core/end2end/fixtures/h2_full+workarounds.cc
@ -44,7 +44,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_full.cc
+++ b/test/core/end2end/fixtures/h2_full.cc
@ -39,7 +39,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_http_proxy.cc
+++ b/test/core/end2end/fixtures/h2_http_proxy.cc
@ -44,7 +44,7 @@ struct fullstack_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* client_args, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  memset(&f, 0, sizeof(f));
  fullstack_fixture_data* ffd = grpc_core::New<fullstack_fixture_data>();
--- a/test/core/end2end/fixtures/h2_local_ipv4.cc
+++ b/test/core/end2end/fixtures/h2_local_ipv4.cc
@ -27,7 +27,7 @@
 #include "test/core/util/test_config.h"

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_ipv4(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f =
      grpc_end2end_local_chttp2_create_fixture_fullstack();
  int port = grpc_pick_unused_port_or_die();
--- a/test/core/end2end/fixtures/h2_local_ipv6.cc
+++ b/test/core/end2end/fixtures/h2_local_ipv6.cc
@ -27,7 +27,7 @@
 #include "test/core/util/test_config.h"

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_ipv6(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f =
      grpc_end2end_local_chttp2_create_fixture_fullstack();
  int port = grpc_pick_unused_port_or_die();
--- a/test/core/end2end/fixtures/h2_local_uds.cc
+++ b/test/core/end2end/fixtures/h2_local_uds.cc
@ -27,7 +27,7 @@
 static int unique = 1;

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack_uds(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f =
      grpc_end2end_local_chttp2_create_fixture_fullstack();
  char* out = nullptr;
--- a/test/core/end2end/fixtures/h2_oauth2.cc
+++ b/test/core/end2end/fixtures/h2_oauth2.cc
@ -76,7 +76,7 @@ static void process_oauth2_success(void* state, grpc_auth_context* ctx,
  cb(user_data, oauth2, 1, nullptr, 0, GRPC_STATUS_OK, nullptr);
 }

-static void process_oauth2_failure(void* state, grpc_auth_context* ctx,
+static void process_oauth2_failure(void* state, grpc_auth_context* /*ctx*/,
                                   const grpc_metadata* md, size_t md_count,
                                   grpc_process_auth_metadata_done_cb cb,
                                   void* user_data) {
@ -91,7 +91,7 @@ static void process_oauth2_failure(void* state, grpc_auth_context* ctx,
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
--- a/test/core/end2end/fixtures/h2_sockpair+trace.cc
+++ b/test/core/end2end/fixtures/h2_sockpair+trace.cc
@ -74,7 +74,7 @@ static void client_setup_transport(void* ts, grpc_transport* transport) {
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_endpoint_pair* sfd =
      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));

--- a/test/core/end2end/fixtures/h2_sockpair.cc
+++ b/test/core/end2end/fixtures/h2_sockpair.cc
@ -69,7 +69,7 @@ static void client_setup_transport(void* ts, grpc_transport* transport) {
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_endpoint_pair* sfd =
      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));

--- a/test/core/end2end/fixtures/h2_sockpair_1byte.cc
+++ b/test/core/end2end/fixtures/h2_sockpair_1byte.cc
@ -69,7 +69,7 @@ static void client_setup_transport(void* ts, grpc_transport* transport) {
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_socketpair(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_endpoint_pair* sfd =
      static_cast<grpc_endpoint_pair*>(gpr_malloc(sizeof(grpc_endpoint_pair)));

--- a/test/core/end2end/fixtures/h2_spiffe.cc
+++ b/test/core/end2end/fixtures/h2_spiffe.cc
@ -53,7 +53,7 @@ struct fullstack_secure_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
@ -66,8 +66,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
@ -136,7 +137,7 @@ static int server_authz_check_async(
 // Synchronous implementation of schedule field in
 // grpc_tls_credential_reload_config instance that is a part of client-side
 // grpc_tls_credentials_options instance.
-static int client_cred_reload_sync(void* config_user_data,
+static int client_cred_reload_sync(void* /*config_user_data*/,
                                   grpc_tls_credential_reload_arg* arg) {
  if (!arg->key_materials_config->pem_key_cert_pair_list().empty()) {
    arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
@ -162,7 +163,7 @@ static int client_cred_reload_sync(void* config_user_data,
 // Synchronous implementation of schedule field in
 // grpc_tls_credential_reload_config instance that is a part of server-side
 // grpc_tls_credentials_options instance.
-static int server_cred_reload_sync(void* config_user_data,
+static int server_cred_reload_sync(void* /*config_user_data*/,
                                   grpc_tls_credential_reload_arg* arg) {
  if (!arg->key_materials_config->pem_key_cert_pair_list().empty()) {
    arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
--- a/test/core/end2end/fixtures/h2_ssl.cc
+++ b/test/core/end2end/fixtures/h2_ssl.cc
@ -39,7 +39,7 @@ struct fullstack_secure_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
@ -55,8 +55,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
--- a/test/core/end2end/fixtures/h2_ssl_cred_reload.cc
+++ b/test/core/end2end/fixtures/h2_ssl_cred_reload.cc
@ -60,7 +60,7 @@ ssl_server_certificate_config_callback(
 }

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
@ -75,8 +75,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
--- a/test/core/end2end/fixtures/h2_ssl_proxy.cc
+++ b/test/core/end2end/fixtures/h2_ssl_proxy.cc
@ -91,8 +91,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
--- a/test/core/end2end/fixtures/h2_uds.cc
+++ b/test/core/end2end/fixtures/h2_uds.cc
@ -44,7 +44,7 @@ typedef struct fullstack_fixture_data {
 static int unique = 1;

 static grpc_end2end_test_fixture chttp2_create_fixture_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  fullstack_fixture_data* ffd = static_cast<fullstack_fixture_data*>(
      gpr_malloc(sizeof(fullstack_fixture_data)));
--- a/test/core/end2end/fixtures/inproc.cc
+++ b/test/core/end2end/fixtures/inproc.cc
@ -38,7 +38,7 @@ typedef struct inproc_fixture_data {
 } inproc_fixture_data;

 static grpc_end2end_test_fixture inproc_create_fixture(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  inproc_fixture_data* ffd = static_cast<inproc_fixture_data*>(
      gpr_malloc(sizeof(inproc_fixture_data)));
--- a/test/core/end2end/fuzzers/api_fuzzer.cc
+++ b/test/core/end2end/fuzzers/api_fuzzer.cc
@ -52,7 +52,7 @@ using grpc_core::testing::input_stream;
 bool squelch = true;
 bool leak_check = true;

-static void dont_log(gpr_log_func_args* args) {}
+static void dont_log(gpr_log_func_args* /*args*/) {}

 ////////////////////////////////////////////////////////////////////////////////
 // global state
@ -358,8 +358,8 @@ static void finish_resolve(void* arg, grpc_error* error) {
  grpc_core::Delete(r);
 }

-void my_resolve_address(const char* addr, const char* default_port,
-                        grpc_pollset_set* interested_parties,
+void my_resolve_address(const char* addr, const char* /*default_port*/,
+                        grpc_pollset_set* /*interested_parties*/,
                        grpc_closure* on_done,
                        grpc_resolved_addresses** addrs) {
  addr_req* r = grpc_core::New<addr_req>();
@ -375,11 +375,11 @@ static grpc_address_resolver_vtable fuzzer_resolver = {my_resolve_address,
                                                       nullptr};

 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,
-    grpc_core::Combiner* combiner) {
+    bool /*check_grpclb*/, char** /*service_config_json*/,
+    int /*query_timeout*/, grpc_core::Combiner* /*combiner*/) {
  addr_req* r = static_cast<addr_req*>(gpr_malloc(sizeof(*r)));
  r->addr = gpr_strdup(addr);
  r->on_done = on_done;
@ -450,9 +450,9 @@ static void sched_connect(grpc_closure* closure, grpc_endpoint** ep,
 }

 static void my_tcp_client_connect(grpc_closure* closure, grpc_endpoint** ep,
-                                  grpc_pollset_set* interested_parties,
-                                  const grpc_channel_args* channel_args,
-                                  const grpc_resolved_address* addr,
+                                  grpc_pollset_set* /*interested_parties*/,
+                                  const grpc_channel_args* /*channel_args*/,
+                                  const grpc_resolved_address* /*addr*/,
                                  grpc_millis deadline) {
  sched_connect(closure, ep,
                grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
@ -481,7 +481,7 @@ static void assert_success_and_decrement(void* counter, bool success) {
  --*static_cast<int*>(counter);
 }

-static void decrement(void* counter, bool success) {
+static void decrement(void* counter, bool /*success*/) {
  --*static_cast<int*>(counter);
 }

@ -662,7 +662,7 @@ typedef struct {
  uint8_t has_ops;
 } batch_info;

-static void finished_batch(void* p, bool success) {
+static void finished_batch(void* p, bool /*success*/) {
  batch_info* bi = static_cast<batch_info*>(p);
  --bi->cs->pending_ops;
  if ((bi->has_ops & (1u << GRPC_OP_RECV_MESSAGE)) &&
--- a/test/core/end2end/fuzzers/client_fuzzer.cc
+++ b/test/core/end2end/fuzzers/client_fuzzer.cc
@ -33,11 +33,11 @@
 bool squelch = true;
 bool leak_check = true;

-static void discard_write(grpc_slice slice) {}
+static void discard_write(grpc_slice /*slice*/) {}

 static void* tag(int n) { return (void*)static_cast<uintptr_t>(n); }

-static void dont_log(gpr_log_func_args* args) {}
+static void dont_log(gpr_log_func_args* /*args*/) {}

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  grpc_test_only_set_slice_hash_seed(0);
--- a/test/core/end2end/fuzzers/server_fuzzer.cc
+++ b/test/core/end2end/fuzzers/server_fuzzer.cc
@ -29,12 +29,12 @@
 bool squelch = true;
 bool leak_check = true;

-static void discard_write(grpc_slice slice) {}
+static void discard_write(grpc_slice /*slice*/) {}

 static void* tag(int n) { return (void*)static_cast<uintptr_t>(n); }
 static int detag(void* p) { return static_cast<int>((uintptr_t)p); }

-static void dont_log(gpr_log_func_args* args) {}
+static void dont_log(gpr_log_func_args* /*args*/) {}

 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  grpc_test_only_set_slice_hash_seed(0);
--- a/test/core/end2end/h2_ssl_cert_test.cc
+++ b/test/core/end2end/h2_ssl_cert_test.cc
@ -45,7 +45,7 @@ struct fullstack_secure_fixture_data {
 };

 static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  int port = grpc_pick_unused_port_or_die();
  fullstack_secure_fixture_data* ffd =
@ -59,8 +59,9 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack(
  return f;
 }

-static void process_auth_failure(void* state, grpc_auth_context* ctx,
-                                 const grpc_metadata* md, size_t md_count,
+static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
+                                 const grpc_metadata* /*md*/,
+                                 size_t /*md_count*/,
                                 grpc_process_auth_metadata_done_cb cb,
                                 void* user_data) {
  GPR_ASSERT(state == nullptr);
--- a/test/core/end2end/inproc_callback_test.cc
+++ b/test/core/end2end/inproc_callback_test.cc
@ -74,7 +74,7 @@ class ShutdownCallback : public grpc_experimental_completion_queue_functor {
    auto* callback = static_cast<ShutdownCallback*>(cb);
    callback->Run(static_cast<bool>(ok));
  }
-  void Run(bool ok) {
+  void Run(bool /*ok*/) {
    gpr_log(GPR_DEBUG, "CQ shutdown notification invoked");
    gpr_mu_lock(&mu_);
    done_ = true;
@ -205,7 +205,7 @@ static grpc_experimental_completion_queue_functor* tag(intptr_t t) {
 }

 static grpc_end2end_test_fixture inproc_create_fixture(
-    grpc_channel_args* client_args, grpc_channel_args* server_args) {
+    grpc_channel_args* /*client_args*/, grpc_channel_args* /*server_args*/) {
  grpc_end2end_test_fixture f;
  inproc_fixture_data* ffd = static_cast<inproc_fixture_data*>(
      gpr_malloc(sizeof(inproc_fixture_data)));
@ -259,7 +259,7 @@ static gpr_timespec n_seconds_from_now(int n) {

 static gpr_timespec five_seconds_from_now() { return n_seconds_from_now(5); }

-static void drain_cq(grpc_completion_queue* cq) {
+static void drain_cq(grpc_completion_queue* /*cq*/) {
  // Wait for the shutdown callback to arrive, or fail the test
  GPR_ASSERT(g_shutdown_callback->Wait(five_seconds_from_now()));
  gpr_log(GPR_DEBUG, "CQ shutdown wait complete");
--- a/test/core/end2end/tests/cancel_test_helpers.h
+++ b/test/core/end2end/tests/cancel_test_helpers.h
@ -26,7 +26,7 @@ typedef struct {
  const char* expect_details;
 } cancellation_mode;

-static grpc_call_error wait_for_deadline(grpc_call* call, void* reserved) {
+static grpc_call_error wait_for_deadline(grpc_call* /*call*/, void* reserved) {
  (void)reserved;
  return GRPC_CALL_OK;
 }
--- a/test/core/end2end/tests/channelz.cc
+++ b/test/core/end2end/tests/channelz.cc
@ -89,7 +89,7 @@ static void end_test(grpc_end2end_test_fixture* f) {
  grpc_completion_queue_destroy(f->shutdown_cq);
 }

-static void run_one_request(grpc_end2end_test_config config,
+static void run_one_request(grpc_end2end_test_config /*config*/,
                            grpc_end2end_test_fixture f,
                            bool request_is_success) {
  grpc_call* c;
--- a/test/core/end2end/tests/connectivity.cc
+++ b/test/core/end2end/tests/connectivity.cc
@ -186,7 +186,7 @@ static void cb_watch_connectivity(
 }

 static void cb_shutdown(grpc_experimental_completion_queue_functor* functor,
-                        int success) {
+                        int /*success*/) {
  CallbackContext* cb_ctx = (CallbackContext*)functor;

  gpr_log(GPR_DEBUG, "cb_shutdown called, nothing to do");
--- a/test/core/end2end/tests/filter_call_init_fails.cc
+++ b/test/core/end2end/tests/filter_call_init_fails.cc
@ -394,23 +394,23 @@ static void test_client_subchannel_filter(grpc_end2end_test_config config) {
 * Test filter - always fails to initialize a call
 */

-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* init_call_elem(grpc_call_element* /*elem*/,
+                                  const grpc_call_element_args* /*args*/) {
  return grpc_error_set_int(
      GRPC_ERROR_CREATE_FROM_STATIC_STRING("access denied"),
      GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_PERMISSION_DENIED);
 }

-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {}
+static void destroy_call_elem(grpc_call_element* /*elem*/,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {}

-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* init_channel_elem(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void destroy_channel_elem(grpc_channel_element* /*elem*/) {}

 static const grpc_channel_filter test_filter = {
    grpc_call_next_op,
@ -430,7 +430,7 @@ static const grpc_channel_filter test_filter = {
 */

 static bool maybe_add_server_channel_filter(grpc_channel_stack_builder* builder,
-                                            void* arg) {
+                                            void* /*arg*/) {
  if (g_enable_server_channel_filter) {
    // Want to add the filter as close to the end as possible, to make
    // sure that all of the filters work well together.  However, we
@ -449,7 +449,7 @@ static bool maybe_add_server_channel_filter(grpc_channel_stack_builder* builder,
 }

 static bool maybe_add_client_channel_filter(grpc_channel_stack_builder* builder,
-                                            void* arg) {
+                                            void* /*arg*/) {
  if (g_enable_client_channel_filter) {
    // Want to add the filter as close to the end as possible, to make
    // sure that all of the filters work well together.  However, we
@ -468,7 +468,7 @@ static bool maybe_add_client_channel_filter(grpc_channel_stack_builder* builder,
 }

 static bool maybe_add_client_subchannel_filter(
-    grpc_channel_stack_builder* builder, void* arg) {
+    grpc_channel_stack_builder* builder, void* /*arg*/) {
  if (g_enable_client_subchannel_filter) {
    // Want to add the filter as close to the end as possible, to make
    // sure that all of the filters work well together.  However, we
--- a/test/core/end2end/tests/filter_causes_close.cc
+++ b/test/core/end2end/tests/filter_causes_close.cc
@ -218,21 +218,21 @@ static void start_transport_stream_op_batch(
  grpc_call_next_op(elem, op);
 }

-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* init_call_elem(grpc_call_element* /*elem*/,
+                                  const grpc_call_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {}
+static void destroy_call_elem(grpc_call_element* /*elem*/,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {}

-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* init_channel_elem(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void destroy_channel_elem(grpc_channel_element* /*elem*/) {}

 static const grpc_channel_filter test_filter = {
    start_transport_stream_op_batch,
@ -251,7 +251,8 @@ static const grpc_channel_filter test_filter = {
 * Registration
 */

-static bool maybe_add_filter(grpc_channel_stack_builder* builder, void* arg) {
+static bool maybe_add_filter(grpc_channel_stack_builder* builder,
+                             void* /*arg*/) {
  if (g_enable_filter) {
    return grpc_channel_stack_builder_prepend_filter(builder, &test_filter,
                                                     nullptr, nullptr);
--- a/test/core/end2end/tests/filter_context.cc
+++ b/test/core/end2end/tests/filter_context.cc
@ -247,16 +247,16 @@ static void start_transport_stream_op_batch(
  grpc_call_next_op(elem, batch);
 }

-static void destroy_call_elem(grpc_call_element* elem,
-                              const grpc_call_final_info* final_info,
-                              grpc_closure* ignored) {}
+static void destroy_call_elem(grpc_call_element* /*elem*/,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {}

-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* init_channel_elem(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void destroy_channel_elem(grpc_channel_element* /*elem*/) {}

 static const grpc_channel_filter test_filter = {
    start_transport_stream_op_batch,
--- a/test/core/end2end/tests/filter_latency.cc
+++ b/test/core/end2end/tests/filter_latency.cc
@ -247,33 +247,33 @@ static void test_request(grpc_end2end_test_config config) {
 * Test latency filter
 */

-static grpc_error* init_call_elem(grpc_call_element* elem,
-                                  const grpc_call_element_args* args) {
+static grpc_error* init_call_elem(grpc_call_element* /*elem*/,
+                                  const grpc_call_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void client_destroy_call_elem(grpc_call_element* elem,
+static void client_destroy_call_elem(grpc_call_element* /*elem*/,
                                     const grpc_call_final_info* final_info,
-                                     grpc_closure* ignored) {
+                                     grpc_closure* /*ignored*/) {
  gpr_mu_lock(&g_mu);
  g_client_latency = final_info->stats.latency;
  gpr_mu_unlock(&g_mu);
 }

-static void server_destroy_call_elem(grpc_call_element* elem,
+static void server_destroy_call_elem(grpc_call_element* /*elem*/,
                                     const grpc_call_final_info* final_info,
-                                     grpc_closure* ignored) {
+                                     grpc_closure* /*ignored*/) {
  gpr_mu_lock(&g_mu);
  g_server_latency = final_info->stats.latency;
  gpr_mu_unlock(&g_mu);
 }

-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* init_channel_elem(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void destroy_channel_elem(grpc_channel_element* /*elem*/) {}

 static const grpc_channel_filter test_client_filter = {
    grpc_call_next_op,
--- a/test/core/end2end/tests/filter_status_code.cc
+++ b/test/core/end2end/tests/filter_status_code.cc
@ -284,7 +284,7 @@ static grpc_error* init_call_elem(grpc_call_element* elem,

 static void client_destroy_call_elem(grpc_call_element* elem,
                                     const grpc_call_final_info* final_info,
-                                     grpc_closure* ignored) {
+                                     grpc_closure* /*ignored*/) {
  final_status_data* data = static_cast<final_status_data*>(elem->call_data);
  gpr_mu_lock(&g_mu);
  // Some fixtures, like proxies, will spawn intermidiate calls
@ -299,7 +299,7 @@ static void client_destroy_call_elem(grpc_call_element* elem,

 static void server_destroy_call_elem(grpc_call_element* elem,
                                     const grpc_call_final_info* final_info,
-                                     grpc_closure* ignored) {
+                                     grpc_closure* /*ignored*/) {
  final_status_data* data = static_cast<final_status_data*>(elem->call_data);
  gpr_mu_lock(&g_mu);
  // Some fixtures, like proxies, will spawn intermidiate calls
@ -312,12 +312,12 @@ static void server_destroy_call_elem(grpc_call_element* elem,
  gpr_mu_unlock(&g_mu);
 }

-static grpc_error* init_channel_elem(grpc_channel_element* elem,
-                                     grpc_channel_element_args* args) {
+static grpc_error* init_channel_elem(grpc_channel_element* /*elem*/,
+                                     grpc_channel_element_args* /*args*/) {
  return GRPC_ERROR_NONE;
 }

-static void destroy_channel_elem(grpc_channel_element* elem) {}
+static void destroy_channel_elem(grpc_channel_element* /*elem*/) {}

 static const grpc_channel_filter test_client_filter = {
    grpc_call_next_op,
--- a/test/core/end2end/tests/no_error_on_hotpath.cc
+++ b/test/core/end2end/tests/no_error_on_hotpath.cc
@ -87,7 +87,7 @@ static void end_test(grpc_end2end_test_fixture* f) {
  grpc_completion_queue_destroy(f->shutdown_cq);
 }

-static void simple_request_body(grpc_end2end_test_config config,
+static void simple_request_body(grpc_end2end_test_config /*config*/,
                                grpc_end2end_test_fixture f) {
  grpc_call* c;
  grpc_call* s;
--- a/test/core/end2end/tests/no_logging.cc
+++ b/test/core/end2end/tests/no_logging.cc
@ -113,7 +113,7 @@ static void end_test(grpc_end2end_test_fixture* f) {
  grpc_completion_queue_destroy(f->shutdown_cq);
 }

-static void simple_request_body(grpc_end2end_test_config config,
+static void simple_request_body(grpc_end2end_test_config /*config*/,
                                grpc_end2end_test_fixture f) {
  grpc_call* c;
  grpc_call* s;
--- a/test/core/end2end/tests/stream_compression_compressed_payload.cc
+++ b/test/core/end2end/tests/stream_compression_compressed_payload.cc
@ -269,8 +269,8 @@ static void request_with_payload_template(
    uint32_t client_send_flags_bitmask,
    grpc_compression_algorithm default_client_channel_compression_algorithm,
    grpc_compression_algorithm default_server_channel_compression_algorithm,
-    grpc_compression_algorithm expected_client_compression_algorithm,
-    grpc_compression_algorithm expected_server_compression_algorithm,
+    grpc_compression_algorithm /*expected_client_compression_algorithm*/,
+    grpc_compression_algorithm /*expected_server_compression_algorithm*/,
    grpc_metadata* client_init_metadata, bool set_server_level,
    grpc_compression_level server_compression_level,
    bool send_message_before_initial_metadata,
--- a/test/core/end2end/tests/stream_compression_payload.cc
+++ b/test/core/end2end/tests/stream_compression_payload.cc
@ -104,7 +104,7 @@ static grpc_slice generate_random_slice() {
  return out;
 }

-static void request_response_with_payload(grpc_end2end_test_config config,
+static void request_response_with_payload(grpc_end2end_test_config /*config*/,
                                          grpc_end2end_test_fixture f) {
  /* Create large request and response bodies. These are big enough to require
   * multiple round trips to deliver to the peer, and their exact contents of
--- a/test/core/fling/fling_stream_test.cc
+++ b/test/core/fling/fling_stream_test.cc
@ -27,7 +27,7 @@
 #include "test/core/util/port.h"
 #include "test/core/util/subprocess.h"

-int main(int argc, char** argv) {
+int main(int /*argc*/, char** argv) {
  char* me = argv[0];
  char* lslash = strrchr(me, '/');
  char root[1024];
--- a/test/core/fling/fling_test.cc
+++ b/test/core/fling/fling_test.cc
@ -28,7 +28,7 @@
 #include "test/core/util/port.h"
 #include "test/core/util/subprocess.h"

-int main(int argc, const char** argv) {
+int main(int /*argc*/, const char** argv) {
  const char* me = argv[0];
  const char* lslash = strrchr(me, '/');
  char root[1024];
--- a/test/core/fling/server.cc
+++ b/test/core/fling/server.cc
@ -167,7 +167,7 @@ static void start_send_status(void) {

 /* We have some sort of deadlock, so let's not exit gracefully for now.
   When that is resolved, please remove the #include <unistd.h> above. */
-static void sigint_handler(int x) { _exit(0); }
+static void sigint_handler(int /*x*/) { _exit(0); }

 int main(int argc, char** argv) {
  grpc_event ev;
--- a/test/core/gpr/log_test.cc
+++ b/test/core/gpr/log_test.cc
@ -37,11 +37,13 @@ static void test_callback(gpr_log_func_args* args) {
  GPR_ASSERT(0 == strcmp(args->message, "hello 1 2 3"));
 }

-static void test_should_log(gpr_log_func_args* args) {
+static void test_should_log(gpr_log_func_args* /*args*/) {
  log_func_reached = true;
 }

-static void test_should_not_log(gpr_log_func_args* args) { GPR_ASSERT(false); }
+static void test_should_not_log(gpr_log_func_args* /*args*/) {
+  GPR_ASSERT(false);
+}

 #define test_log_function_reached(SEVERITY)     \
  gpr_set_log_function(test_should_log);        \
--- a/test/core/gpr/tls_test.cc
+++ b/test/core/gpr/tls_test.cc
@ -33,7 +33,7 @@

 GPR_TLS_DECL(test_var);

-static void thd_body(void* arg) {
+static void thd_body(void* /*arg*/) {
  intptr_t i;

  GPR_ASSERT(gpr_tls_get(&test_var) == 0);
--- a/test/core/gprpp/global_config_env_test.cc
+++ b/test/core/gprpp/global_config_env_test.cc
@ -39,7 +39,7 @@ bool IsConfigErrorCalled() { return g_config_error_function_called; }
 // This function is for preventing the program from invoking
 // an error handler due to configuration error and
 // make test routines know whether there is error.
-void FakeConfigErrorFunction(const char* error_message) {
+void FakeConfigErrorFunction(const char* /*error_message*/) {
  g_config_error_function_called = true;
 }

--- a/test/core/gprpp/thd_test.cc
+++ b/test/core/gprpp/thd_test.cc
@ -75,7 +75,7 @@ static void test1(void) {
  gpr_cv_destroy(&t.done_cv);
 }

-static void thd_body2(void* v) {}
+static void thd_body2(void* /*v*/) {}

 /* Test that we can create a number of threads and join them. */
 static void test2(void) {
--- a/test/core/handshake/client_ssl.cc
+++ b/test/core/handshake/client_ssl.cc
@ -98,7 +98,7 @@ static int create_socket(int* out_port) {

 // Server callback during ALPN negotiation. See man page for
 // SSL_CTX_set_alpn_select_cb.
-static int alpn_select_cb(SSL* ssl, const uint8_t** out, uint8_t* out_len,
+static int alpn_select_cb(SSL* /*ssl*/, const uint8_t** out, uint8_t* out_len,
                          const uint8_t* in, unsigned in_len, void* arg) {
  const uint8_t* alpn_preferred = static_cast<const uint8_t*>(arg);

@ -309,7 +309,7 @@ static bool client_ssl_test(char* server_alpn_preferred) {
  return success;
 }

-int main(int argc, char* argv[]) {
+int main(int /*argc*/, char* /*argv*/ []) {
  // Handshake succeeeds when the server has grpc-exp as the ALPN preference.
  GPR_ASSERT(client_ssl_test(const_cast<char*>("grpc-exp")));
  // Handshake succeeeds when the server has h2 as the ALPN preference. This
--- a/test/core/handshake/readahead_handshaker_server_ssl.cc
+++ b/test/core/handshake/readahead_handshaker_server_ssl.cc
@ -55,8 +55,8 @@ class ReadAheadHandshaker : public Handshaker {
 public:
  virtual ~ReadAheadHandshaker() {}
  const char* name() const override { return "read_ahead"; }
-  void Shutdown(grpc_error* why) override {}
-  void DoHandshake(grpc_tcp_server_acceptor* acceptor,
+  void Shutdown(grpc_error* /*why*/) override {}
+  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                   grpc_closure* on_handshake_done,
                   HandshakerArgs* args) override {
    grpc_endpoint_read(args->endpoint, args->read_buffer, on_handshake_done,
@ -66,8 +66,8 @@ class ReadAheadHandshaker : public Handshaker {

 class ReadAheadHandshakerFactory : public HandshakerFactory {
 public:
-  void AddHandshakers(const grpc_channel_args* args,
-                      grpc_pollset_set* interested_parties,
+  void AddHandshakers(const grpc_channel_args* /*args*/,
+                      grpc_pollset_set* /*interested_parties*/,
                      HandshakeManager* handshake_mgr) override {
    handshake_mgr->Add(MakeRefCounted<ReadAheadHandshaker>());
  }
@ -76,7 +76,7 @@ class ReadAheadHandshakerFactory : public HandshakerFactory {

 }  // namespace grpc_core

-int main(int argc, char* argv[]) {
+int main(int /*argc*/, char* /*argv*/ []) {
  using namespace grpc_core;
  grpc_init();
  HandshakerRegistry::RegisterHandshakerFactory(
--- a/test/core/handshake/server_ssl.cc
+++ b/test/core/handshake/server_ssl.cc
@ -36,7 +36,7 @@

 #include "test/core/handshake/server_ssl_common.h"

-int main(int argc, char* argv[]) {
+int main(int /*argc*/, char* /*argv*/ []) {
  // Handshake succeeeds when the client supplies the standard ALPN list.
  const char* full_alpn_list[] = {"grpc-exp", "h2"};
  GPR_ASSERT(server_ssl_test(full_alpn_list, 2, "grpc-exp"));
--- a/test/core/handshake/verify_peer_options.cc
+++ b/test/core/handshake/verify_peer_options.cc
@ -228,7 +228,7 @@ static int verify_callback(const char* target_host, const char* target_pem,

 static void verify_destruct(void* userdata) { destruct_userdata = userdata; }

-int main(int argc, char* argv[]) {
+int main(int /*argc*/, char* /*argv*/ []) {
  int userdata = 42;
  verify_peer_options verify_options;

--- a/test/core/http/httpcli_test.cc
+++ b/test/core/http/httpcli_test.cc
@ -138,7 +138,7 @@ static void test_post(int port) {
  grpc_http_response_destroy(&response);
 }

-static void destroy_pops(void* p, grpc_error* error) {
+static void destroy_pops(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(
      grpc_polling_entity_pollset(static_cast<grpc_polling_entity*>(p)));
 }
--- a/test/core/http/httpscli_test.cc
+++ b/test/core/http/httpscli_test.cc
@ -143,7 +143,7 @@ static void test_post(int port) {
  grpc_http_response_destroy(&response);
 }

-static void destroy_pops(void* p, grpc_error* error) {
+static void destroy_pops(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(
      grpc_polling_entity_pollset(static_cast<grpc_polling_entity*>(p)));
 }
--- a/test/core/iomgr/buffer_list_test.cc
+++ b/test/core/iomgr/buffer_list_test.cc
@ -27,7 +27,7 @@
 #ifdef GRPC_LINUX_ERRQUEUE

 static void TestShutdownFlushesListVerifier(void* arg,
-                                            grpc_core::Timestamps* ts,
+                                            grpc_core::Timestamps* /*ts*/,
                                            grpc_error* error) {
  GPR_ASSERT(error == GRPC_ERROR_NONE);
  GPR_ASSERT(arg != nullptr);
--- a/test/core/iomgr/combiner_test.cc
+++ b/test/core/iomgr/combiner_test.cc
@ -32,7 +32,7 @@ static void test_no_op(void) {
  GRPC_COMBINER_UNREF(grpc_combiner_create(), "test_no_op");
 }

-static void set_event_to_true(void* value, grpc_error* error) {
+static void set_event_to_true(void* value, grpc_error* /*error*/) {
  gpr_event_set(static_cast<gpr_event*>(value), (void*)1);
 }

@ -62,7 +62,7 @@ typedef struct {
  size_t value;
 } ex_args;

-static void check_one(void* a, grpc_error* error) {
+static void check_one(void* a, grpc_error* /*error*/) {
  ex_args* args = static_cast<ex_args*>(a);
  GPR_ASSERT(*args->ctr == args->value - 1);
  *args->ctr = args->value;
@ -114,11 +114,11 @@ static void test_execute_many(void) {

 static gpr_event got_in_finally;

-static void in_finally(void* arg, grpc_error* error) {
+static void in_finally(void* /*arg*/, grpc_error* /*error*/) {
  gpr_event_set(&got_in_finally, (void*)1);
 }

-static void add_finally(void* arg, grpc_error* error) {
+static void add_finally(void* arg, grpc_error* /*error*/) {
  static_cast<grpc_core::Combiner*>(arg)->Run(
      GRPC_CLOSURE_CREATE(in_finally, arg, nullptr), GRPC_ERROR_NONE);
 }
--- a/test/core/iomgr/endpoint_pair_test.cc
+++ b/test/core/iomgr/endpoint_pair_test.cc
@ -54,7 +54,7 @@ static grpc_endpoint_test_config configs[] = {
    {"tcp/tcp_socketpair", create_fixture_endpoint_pair, clean_up},
 };

-static void destroy_pollset(void* p, grpc_error* error) {
+static void destroy_pollset(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
 }

--- a/test/core/iomgr/ev_epollex_linux_test.cc
+++ b/test/core/iomgr/ev_epollex_linux_test.cc
@ -27,7 +27,7 @@

 #include "test/core/util/test_config.h"

-static void pollset_destroy(void* ps, grpc_error* error) {
+static void pollset_destroy(void* ps, grpc_error* /*error*/) {
  grpc_pollset_destroy(static_cast<grpc_pollset*>(ps));
  gpr_free(ps);
 }
--- a/test/core/iomgr/fd_posix_test.cc
+++ b/test/core/iomgr/fd_posix_test.cc
@ -82,7 +82,7 @@ static void create_test_socket(int port, int* socket_fd,
 }

 /* Dummy gRPC callback */
-void no_op_cb(void* arg, int success) {}
+void no_op_cb(void* /*arg*/, int /*success*/) {}

 /* =======An upload server to test notify_on_read===========
   The server simply reads and counts a stream of bytes. */
@ -112,7 +112,7 @@ typedef struct {
 /* Called when an upload session can be safely shutdown.
   Close session FD and start to shutdown listen FD. */
 static void session_shutdown_cb(void* arg, /*session */
-                                bool success) {
+                                bool /*success*/) {
  session* se = static_cast<session*>(arg);
  server* sv = se->sv;
  grpc_fd_orphan(se->em_fd, nullptr, nullptr, "a");
@ -168,7 +168,7 @@ static void session_read_cb(void* arg, /*session */

 /* Called when the listen FD can be safely shutdown.
   Close listen FD and signal that server can be shutdown. */
-static void listen_shutdown_cb(void* arg /*server */, int success) {
+static void listen_shutdown_cb(void* arg /*server*/, int /*success*/) {
  server* sv = static_cast<server*>(arg);

  grpc_fd_orphan(sv->em_fd, nullptr, nullptr, "b");
@ -287,7 +287,7 @@ static void client_init(client* cl) {
 }

 /* Called when a client upload session is ready to shutdown. */
-static void client_session_shutdown_cb(void* arg /*client */, int success) {
+static void client_session_shutdown_cb(void* arg /*client*/, int /*success*/) {
  client* cl = static_cast<client*>(arg);
  grpc_fd_orphan(cl->em_fd, nullptr, nullptr, "c");
  cl->done = 1;
@ -401,10 +401,10 @@ typedef struct fd_change_data {

 void init_change_data(fd_change_data* fdc) { fdc->cb_that_ran = nullptr; }

-void destroy_change_data(fd_change_data* fdc) {}
+void destroy_change_data(fd_change_data* /*fdc*/) {}

 static void first_read_callback(void* arg /* fd_change_data */,
-                                grpc_error* error) {
+                                grpc_error* /*error*/) {
  fd_change_data* fdc = static_cast<fd_change_data*>(arg);

  gpr_mu_lock(g_mu);
@ -415,7 +415,7 @@ static void first_read_callback(void* arg /* fd_change_data */,
 }

 static void second_read_callback(void* arg /* fd_change_data */,
-                                 grpc_error* error) {
+                                 grpc_error* /*error*/) {
  fd_change_data* fdc = static_cast<fd_change_data*>(arg);

  gpr_mu_lock(g_mu);
@ -509,7 +509,7 @@ static void test_grpc_fd_change(void) {
  close(sv[1]);
 }

-static void destroy_pollset(void* p, grpc_error* error) {
+static void destroy_pollset(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
 }

--- a/test/core/iomgr/resolve_address_posix_test.cc
+++ b/test/core/iomgr/resolve_address_posix_test.cc
@ -53,7 +53,7 @@ typedef struct args_struct {
  grpc_pollset_set* pollset_set;
 } args_struct;

-static void do_nothing(void* arg, grpc_error* error) {}
+static void do_nothing(void* /*arg*/, grpc_error* /*error*/) {}

 void args_init(args_struct* args) {
  gpr_event_init(&args->ev);
--- a/test/core/iomgr/resolve_address_test.cc
+++ b/test/core/iomgr/resolve_address_test.cc
@ -47,7 +47,7 @@ typedef struct args_struct {
  grpc_pollset_set* pollset_set;
 } args_struct;

-static void do_nothing(void* arg, grpc_error* error) {}
+static void do_nothing(void* /*arg*/, grpc_error* /*error*/) {}

 void args_init(args_struct* args) {
  gpr_event_init(&args->ev);
@ -310,7 +310,7 @@ typedef struct mock_ipv6_disabled_source_addr_factory {
 } mock_ipv6_disabled_source_addr_factory;

 static bool mock_ipv6_disabled_source_addr_factory_get_source_addr(
-    address_sorting_source_addr_factory* factory,
+    address_sorting_source_addr_factory* /*factory*/,
    const address_sorting_address* dest_addr,
    address_sorting_address* source_addr) {
  // Mock lack of IPv6. For IPv4, set the source addr to be the same
--- a/test/core/iomgr/resource_quota_test.cc
+++ b/test/core/iomgr/resource_quota_test.cc
@ -28,7 +28,7 @@
 gpr_mu g_mu;
 gpr_cv g_cv;

-static void inc_int_cb(void* a, grpc_error* error) {
+static void inc_int_cb(void* a, grpc_error* /*error*/) {
  gpr_mu_lock(&g_mu);
  ++*static_cast<int*>(a);
  gpr_cv_signal(&g_cv);
@ -44,7 +44,7 @@ static void assert_counter_becomes(int* ctr, int value) {
  gpr_mu_unlock(&g_mu);
 }

-static void set_event_cb(void* a, grpc_error* error) {
+static void set_event_cb(void* a, grpc_error* /*error*/) {
  gpr_event_set(static_cast<gpr_event*>(a), (void*)1);
 }
 grpc_closure* set_event(gpr_event* ev) {
--- a/test/core/iomgr/tcp_client_posix_test.cc
+++ b/test/core/iomgr/tcp_client_posix_test.cc
@ -60,7 +60,7 @@ static void finish_connection() {
  gpr_mu_unlock(g_mu);
 }

-static void must_succeed(void* arg, grpc_error* error) {
+static void must_succeed(void* /*arg*/, grpc_error* error) {
  GPR_ASSERT(g_connecting != nullptr);
  GPR_ASSERT(error == GRPC_ERROR_NONE);
  grpc_endpoint_shutdown(g_connecting, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@ -70,7 +70,7 @@ static void must_succeed(void* arg, grpc_error* error) {
  finish_connection();
 }

-static void must_fail(void* arg, grpc_error* error) {
+static void must_fail(void* /*arg*/, grpc_error* error) {
  GPR_ASSERT(g_connecting == nullptr);
  GPR_ASSERT(error != GRPC_ERROR_NONE);
  finish_connection();
@ -185,7 +185,7 @@ void test_fails(void) {
  gpr_mu_unlock(g_mu);
 }

-static void destroy_pollset(void* p, grpc_error* error) {
+static void destroy_pollset(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
 }

--- a/test/core/iomgr/tcp_posix_test.cc
+++ b/test/core/iomgr/tcp_posix_test.cc
@ -472,7 +472,7 @@ static void write_test(size_t num_bytes, size_t slice_size,
  gpr_free(slices);
 }

-void on_fd_released(void* arg, grpc_error* errors) {
+void on_fd_released(void* arg, grpc_error* /*errors*/) {
  int* done = static_cast<int*>(arg);
  *done = 1;
  GPR_ASSERT(
@ -618,7 +618,7 @@ static grpc_endpoint_test_config configs[] = {
    {"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
 };

-static void destroy_pollset(void* p, grpc_error* error) {
+static void destroy_pollset(void* p, grpc_error* /*error*/) {
  grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
 }

--- a/Show More
+++ b/Show More