Remove unused parameter warning (18 of 20)

test/cpp/microbenchmarks/bm_chttp2_transport.cc

@@ -91,22 +91,23 @@ class DummyEndpoint : public grpc_endpoint {
   }
 
   static void read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                   grpc_closure* cb, bool urgent) {
+                   grpc_closure* cb, bool /*urgent*/) {
     static_cast<DummyEndpoint*>(ep)->QueueRead(slices, cb);
   }
 
-  static void write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                    grpc_closure* cb, void* arg) {
+  static void write(grpc_endpoint* /*ep*/, grpc_slice_buffer* /*slices*/,
+                    grpc_closure* cb, void* /*arg*/) {
     GRPC_CLOSURE_SCHED(cb, GRPC_ERROR_NONE);
   }
 
-  static void add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {}
+  static void add_to_pollset(grpc_endpoint* /*ep*/,
+                             grpc_pollset* /*pollset*/) {}
 
-  static void add_to_pollset_set(grpc_endpoint* ep, grpc_pollset_set* pollset) {
-  }
+  static void add_to_pollset_set(grpc_endpoint* /*ep*/,
+                                 grpc_pollset_set* /*pollset*/) {}
 
-  static void delete_from_pollset_set(grpc_endpoint* ep,
-                                      grpc_pollset_set* pollset) {}
+  static void delete_from_pollset_set(grpc_endpoint* /*ep*/,
+                                      grpc_pollset_set* /*pollset*/) {}
 
   static void shutdown(grpc_endpoint* ep, grpc_error* why) {
     grpc_resource_user_shutdown(static_cast<DummyEndpoint*>(ep)->ru_);
@@ -121,9 +122,9 @@ class DummyEndpoint : public grpc_endpoint {
   static grpc_resource_user* get_resource_user(grpc_endpoint* ep) {
     return static_cast<DummyEndpoint*>(ep)->ru_;
   }
-  static char* get_peer(grpc_endpoint* ep) { return gpr_strdup("test"); }
-  static int get_fd(grpc_endpoint* ep) { return 0; }
-  static bool can_track_err(grpc_endpoint* ep) { return false; }
+  static char* get_peer(grpc_endpoint* /*ep*/) { return gpr_strdup("test"); }
+  static int get_fd(grpc_endpoint* /*ep*/) { return 0; }
+  static bool can_track_err(grpc_endpoint* /*ep*/) { return false; }
 };
 
 class Fixture {
@@ -234,7 +235,7 @@ class Stream {
   }
 
  private:
-  static void FinishDestroy(void* arg, grpc_error* error) {
+  static void FinishDestroy(void* arg, grpc_error* /*error*/) {
     auto stream = static_cast<Stream*>(arg);
     grpc_transport_destroy_stream(stream->f_->transport(),
                                   static_cast<grpc_stream*>(stream->stream_),
@@ -267,7 +268,7 @@ static void BM_StreamCreateDestroy(benchmark::State& state) {
   op.cancel_stream = true;
   op.payload = &op_payload;
   op_payload.cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
-  std::unique_ptr<Closure> next = MakeClosure([&, s](grpc_error* error) {
+  std::unique_ptr<Closure> next = MakeClosure([&, s](grpc_error* /*error*/) {
     if (!state.KeepRunning()) {
       delete s;
       return;
@@ -333,7 +334,7 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State& state) {
   f.FlushExecCtx();
   gpr_event bm_done;
   gpr_event_init(&bm_done);
-  start = MakeClosure([&, s](grpc_error* error) {
+  start = MakeClosure([&, s](grpc_error* /*error*/) {
     if (!state.KeepRunning()) {
       delete s;
       gpr_event_set(&bm_done, (void*)1);
@@ -346,7 +347,7 @@ static void BM_StreamCreateSendInitialMetadataDestroy(benchmark::State& state) {
     op.payload->send_initial_metadata.send_initial_metadata = &b;
     s->Op(&op);
   });
-  done = MakeClosure([&](grpc_error* error) {
+  done = MakeClosure([&](grpc_error* /*error*/) {
     reset_op();
     op.cancel_stream = true;
     op.payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
@@ -374,7 +375,7 @@ static void BM_TransportEmptyOp(benchmark::State& state) {
     op = {};
     op.payload = &op_payload;
   };
-  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* /*error*/) {
     if (!state.KeepRunning()) return;
     reset_op();
     op.on_complete = c.get();
@@ -397,7 +398,7 @@ static void BM_TransportEmptyOp(benchmark::State& state) {
   f.FlushExecCtx();
   gpr_event_wait(stream_cancel_done, gpr_inf_future(GPR_CLOCK_REALTIME));
   done_events.emplace_back(stream_cancel_done);
-  s->DestroyThen(MakeOnceClosure([s](grpc_error* error) { delete s; }));
+  s->DestroyThen(MakeOnceClosure([s](grpc_error* /*error*/) { delete s; }));
   f.FlushExecCtx();
   track_counters.Finish(state);
 }
@@ -436,7 +437,7 @@ static void BM_TransportStreamSend(benchmark::State& state) {
   gpr_event* bm_done = new gpr_event;
   gpr_event_init(bm_done);
 
-  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* /*error*/) {
     if (!state.KeepRunning()) {
       gpr_event_set(bm_done, (void*)(1));
       return;
@@ -481,7 +482,7 @@ static void BM_TransportStreamSend(benchmark::State& state) {
   f.FlushExecCtx();
   gpr_event_wait(stream_cancel_done, gpr_inf_future(GPR_CLOCK_REALTIME));
   done_events.emplace_back(stream_cancel_done);
-  s->DestroyThen(MakeOnceClosure([s](grpc_error* error) { delete s; }));
+  s->DestroyThen(MakeOnceClosure([s](grpc_error* /*error*/) { delete s; }));
   f.FlushExecCtx();
   track_counters.Finish(state);
   grpc_metadata_batch_destroy(&b);
@@ -575,7 +576,8 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
         "addmd", grpc_metadata_batch_add_tail(&b, &storage[i], elems[i])));
   }
 
-  std::unique_ptr<Closure> do_nothing = MakeClosure([](grpc_error* error) {});
+  std::unique_ptr<Closure> do_nothing =
+      MakeClosure([](grpc_error* /*error*/) {});
 
   uint32_t received;
 
@@ -584,7 +586,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   std::unique_ptr<Closure> drain_continue;
   grpc_slice recv_slice;
 
-  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* error) {
+  std::unique_ptr<Closure> c = MakeClosure([&](grpc_error* /*error*/) {
     if (!state.KeepRunning()) return;
     // force outgoing window to be yuge
     s->chttp2_stream()->flow_control->TestOnlyForceHugeWindow();
@@ -599,7 +601,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
     f.PushInput(grpc_slice_ref(incoming_data));
   });
 
-  drain_start = MakeClosure([&](grpc_error* error) {
+  drain_start = MakeClosure([&](grpc_error* /*error*/) {
     if (recv_stream == nullptr) {
       GPR_ASSERT(!state.KeepRunning());
       return;
@@ -607,7 +609,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
     GRPC_CLOSURE_RUN(drain.get(), GRPC_ERROR_NONE);
   });
 
-  drain = MakeClosure([&](grpc_error* error) {
+  drain = MakeClosure([&](grpc_error* /*error*/) {
     do {
       if (received == recv_stream->length()) {
         recv_stream.reset();
@@ -621,7 +623,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
               grpc_slice_unref_internal(recv_slice), true));
   });
 
-  drain_continue = MakeClosure([&](grpc_error* error) {
+  drain_continue = MakeClosure([&](grpc_error* /*error*/) {
     recv_stream->Pull(&recv_slice);
     received += GRPC_SLICE_LENGTH(recv_slice);
     grpc_slice_unref_internal(recv_slice);
@@ -666,7 +668,7 @@ static void BM_TransportStreamRecv(benchmark::State& state) {
   f.FlushExecCtx();
   gpr_event_wait(stream_cancel_done, gpr_inf_future(GPR_CLOCK_REALTIME));
   done_events.emplace_back(stream_cancel_done);
-  s->DestroyThen(MakeOnceClosure([s](grpc_error* error) { delete s; }));
+  s->DestroyThen(MakeOnceClosure([s](grpc_error* /*error*/) { delete s; }));
   grpc_metadata_batch_destroy(&b);
   grpc_metadata_batch_destroy(&b_recv);
   f.FlushExecCtx();

test/cpp/microbenchmarks/bm_closure.cc

@@ -50,7 +50,7 @@ static void BM_WellFlushed(benchmark::State& state) {
 }
 BENCHMARK(BM_WellFlushed);
 
-static void DoNothing(void* arg, grpc_error* error) {}
+static void DoNothing(void* /*arg*/, grpc_error* /*error*/) {}
 
 static void BM_ClosureInitAgainstExecCtx(benchmark::State& state) {
   TrackCounters track_counters;
@@ -372,7 +372,7 @@ class Rescheduler {
   benchmark::State& state_;
   grpc_closure closure_;
 
-  static void Step(void* arg, grpc_error* error) {
+  static void Step(void* arg, grpc_error* /*error*/) {
     Rescheduler* self = static_cast<Rescheduler*>(arg);
     if (self->state_.KeepRunning()) {
       GRPC_CLOSURE_SCHED(&self->closure_, GRPC_ERROR_NONE);

test/cpp/microbenchmarks/bm_cq.cc

@@ -65,12 +65,14 @@ static void BM_CreateDestroyCore(benchmark::State& state) {
 }
 BENCHMARK(BM_CreateDestroyCore);
 
-static void DoneWithCompletionOnStack(void* arg,
-                                      grpc_cq_completion* completion) {}
+static void DoneWithCompletionOnStack(void* /*arg*/,
+                                      grpc_cq_completion* /*completion*/) {}
 
 class DummyTag final : public internal::CompletionQueueTag {
  public:
-  bool FinalizeResult(void** tag, bool* status) override { return true; }
+  bool FinalizeResult(void** /*tag*/, bool* /*status*/) override {
+    return true;
+  }
 };
 
 static void BM_Pass1Cpp(benchmark::State& state) {

test/cpp/microbenchmarks/bm_cq_multiple_threads.cc

@@ -44,7 +44,7 @@ namespace testing {
 static grpc_completion_queue* g_cq;
 static grpc_event_engine_vtable g_vtable;
 
-static void pollset_shutdown(grpc_pollset* ps, grpc_closure* closure) {
+static void pollset_shutdown(grpc_pollset* /*ps*/, grpc_closure* closure) {
   GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
 }
 
@@ -55,18 +55,21 @@ static void pollset_init(grpc_pollset* ps, gpr_mu** mu) {
 
 static void pollset_destroy(grpc_pollset* ps) { gpr_mu_destroy(&ps->mu); }
 
-static grpc_error* pollset_kick(grpc_pollset* p, grpc_pollset_worker* worker) {
+static grpc_error* pollset_kick(grpc_pollset* /*p*/,
+                                grpc_pollset_worker* /*worker*/) {
   return GRPC_ERROR_NONE;
 }
 
 /* Callback when the tag is dequeued from the completion queue. Does nothing */
-static void cq_done_cb(void* done_arg, grpc_cq_completion* cq_completion) {
+static void cq_done_cb(void* /*done_arg*/,
+                       grpc_cq_completion* cq_completion) {
   gpr_free(cq_completion);
 }
 
 /* Queues a completion tag if deadline is > 0.
  * Does nothing if deadline is 0 (i.e gpr_time_0(GPR_CLOCK_MONOTONIC)) */
-static grpc_error* pollset_work(grpc_pollset* ps, grpc_pollset_worker** worker,
+static grpc_error* pollset_work(grpc_pollset* ps,
+                                grpc_pollset_worker** /*worker*/,
                                 grpc_millis deadline) {
   if (deadline == 0) {
     gpr_log(GPR_DEBUG, "no-op");
@@ -95,8 +98,10 @@ static const grpc_event_engine_vtable* init_engine_vtable(bool) {
   g_vtable.pollset_work = pollset_work;
   g_vtable.pollset_kick = pollset_kick;
   g_vtable.is_any_background_poller_thread = [] { return false; };
-  g_vtable.add_closure_to_background_poller =
-      [](grpc_closure* closure, grpc_error* error) { return false; };
+  g_vtable.add_closure_to_background_poller = [](grpc_closure* /*closure*/,
+                                                 grpc_error* /*error*/) {
+    return false;
+  };
   g_vtable.shutdown_background_closure = [] {};
   g_vtable.shutdown_engine = [] {};
 

test/cpp/microbenchmarks/bm_pollset.cc

@@ -40,7 +40,7 @@
 #include <unistd.h>
 #endif
 
-static void shutdown_ps(void* ps, grpc_error* error) {
+static void shutdown_ps(void* ps, grpc_error* /*error*/) {
   grpc_pollset_destroy(static_cast<grpc_pollset*>(ps));
 }
 
@@ -168,7 +168,7 @@ Closure* MakeClosure(F f, grpc_closure_scheduler* scheduler) {
     C(F f, grpc_closure_scheduler* scheduler) : f_(f) {
       GRPC_CLOSURE_INIT(this, C::cbfn, this, scheduler);
     }
-    static void cbfn(void* arg, grpc_error* error) {
+    static void cbfn(void* arg, grpc_error* /*error*/) {
       C* p = static_cast<C*>(arg);
       p->f_();
     }

test/cpp/microbenchmarks/bm_threadpool.cc

@@ -72,7 +72,8 @@ class AddAnotherFunctor : public grpc_experimental_completion_queue_functor {
   }
   // When the functor gets to run in thread pool, it will take itself as first
   // argument and internal_success as second one.
-  static void Run(grpc_experimental_completion_queue_functor* cb, int ok) {
+  static void Run(grpc_experimental_completion_queue_functor* cb,
+                  int /*ok*/) {
     auto* callback = static_cast<AddAnotherFunctor*>(cb);
     if (--callback->num_add_ > 0) {
       callback->pool_->Add(new AddAnotherFunctor(
@@ -134,7 +135,8 @@ class SuicideFunctorForAdd : public grpc_experimental_completion_queue_functor {
     internal_success = 0;
   }
 
-  static void Run(grpc_experimental_completion_queue_functor* cb, int ok) {
+  static void Run(grpc_experimental_completion_queue_functor* cb,
+                  int /*ok*/) {
     // On running, the first argument would be itself.
     auto* callback = static_cast<SuicideFunctorForAdd*>(cb);
     callback->counter_->DecrementCount();
@@ -187,7 +189,8 @@ class AddSelfFunctor : public grpc_experimental_completion_queue_functor {
   }
   // When the functor gets to run in thread pool, it will take itself as first
   // argument and internal_success as second one.
-  static void Run(grpc_experimental_completion_queue_functor* cb, int ok) {
+  static void Run(grpc_experimental_completion_queue_functor* cb,
+                  int /*ok*/) {
     auto* callback = static_cast<AddSelfFunctor*>(cb);
     if (--callback->num_add_ > 0) {
       callback->pool_->Add(cb);
@@ -265,7 +268,8 @@ class ShortWorkFunctorForAdd
     internal_success = 0;
     val_ = 0;
   }
-  static void Run(grpc_experimental_completion_queue_functor* cb, int ok) {
+  static void Run(grpc_experimental_completion_queue_functor* cb,
+                  int /*ok*/) {
     auto* callback = static_cast<ShortWorkFunctorForAdd*>(cb);
     // Uses pad to avoid compiler complaining unused variable error.
     callback->pad[0] = 0;

test/cpp/microbenchmarks/fullstack_context_mutators.h

@@ -52,7 +52,7 @@ auto MakeVector(size_t length, F f) -> std::vector<decltype(f())> {
 class NoOpMutator {
  public:
   template <class ContextType>
-  NoOpMutator(ContextType* context) {}
+  NoOpMutator(ContextType* /*context*/) {}
 };
 
 template <int length>

test/cpp/microbenchmarks/fullstack_fixtures.h

@@ -68,7 +68,7 @@ class BaseFixture : public TrackCounters {};
 // code easier.
 class ShutdownTag : public internal::CompletionQueueTag {
  public:
-  bool FinalizeResult(void** tag, bool* status) { return false; }
+  bool FinalizeResult(void** /*tag*/, bool* /*status*/) { return false; }
 };
 
 class FullstackFixture : public BaseFixture {

test/cpp/naming/cancel_ares_query_test.cc

@@ -95,7 +95,7 @@ void ArgsInit(ArgsStruct* args) {
   args->channel_args = nullptr;
 }
 
-void DoNothing(void* arg, grpc_error* error) {}
+void DoNothing(void* /*arg*/, grpc_error* /*error*/) {}
 
 void ArgsFinish(ArgsStruct* args) {
   grpc_pollset_set_del_pollset(args->pollset_set, args->pollset);
@@ -142,11 +142,11 @@ class AssertFailureResultHandler : public grpc_core::Resolver::ResultHandler {
     gpr_mu_unlock(args_->mu);
   }
 
-  void ReturnResult(grpc_core::Resolver::Result result) override {
+  void ReturnResult(grpc_core::Resolver::Result /*result*/) override {
     GPR_ASSERT(false);
   }
 
-  void ReturnError(grpc_error* error) override { GPR_ASSERT(false); }
+  void ReturnError(grpc_error* /*error*/) override { GPR_ASSERT(false); }
 
  private:
   ArgsStruct* args_;

test/cpp/naming/resolver_component_test.cc

@@ -211,7 +211,7 @@ void ArgsInit(ArgsStruct* args) {
   args->channel_args = nullptr;
 }
 
-void DoNothing(void* arg, grpc_error* error) {}
+void DoNothing(void* /*arg*/, grpc_error* /*error*/) {}
 
 void ArgsFinish(ArgsStruct* args) {
   GPR_ASSERT(gpr_event_wait(&args->ev, TestDeadline()));
@@ -442,7 +442,7 @@ class ResultHandler : public grpc_core::Resolver::ResultHandler {
     GPR_ASSERT(false);
   }
 
-  virtual void CheckResult(const grpc_core::Resolver::Result& result) {}
+  virtual void CheckResult(const grpc_core::Resolver::Result& /*result*/) {}
 
  protected:
   ArgsStruct* args_struct() const { return args_; }
@@ -534,7 +534,7 @@ void InjectBrokenNameServerList(ares_channel channel) {
   GPR_ASSERT(ares_set_servers_ports(channel, dns_server_addrs) == ARES_SUCCESS);
 }
 
-void StartResolvingLocked(void* arg, grpc_error* unused) {
+void StartResolvingLocked(void* arg, grpc_error* /*unused*/) {
   grpc_core::Resolver* r = static_cast<grpc_core::Resolver*>(arg);
   r->StartLocked();
 }