Comment unused variables in implemented functions 14\n

Bug: webrtc:370878648 Change-Id: I7c48313e64fafb8f23121e9bae1d50c3d32f7d07 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/366983 Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Dor Hen <dorhen@meta.com> Cr-Commit-Position: refs/heads/main@{#43414}
2024-11-11 15:51:41 +02:00 · 2024-11-11 15:51:41 +02:00 · 69cc695699
commit 69cc695699
parent bda11ca6da
58 changed files with 182 additions and 163 deletions
--- a/call/call.cc
+++ b/call/call.cc
@ -110,12 +110,12 @@ namespace {
 class PayloadTypeSuggesterForTests : public PayloadTypeSuggester {
 public:
  PayloadTypeSuggesterForTests() = default;
-  RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& mid,
+  RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& /* mid */,
                                             cricket::Codec codec) override {
    return payload_type_picker_.SuggestMapping(codec, nullptr);
  }
-  RTCError AddLocalMapping(const std::string& mid,
-                           PayloadType payload_type,
+  RTCError AddLocalMapping(const std::string& /* mid */,
+                           PayloadType /* payload_type */,
                           const cricket::Codec& codec) override {
    return RTCError::OK();
  }
--- a/modules/audio_device/include/audio_device_default.h
+++ b/modules/audio_device/include/audio_device_default.h
@ -124,7 +124,7 @@ class AudioDeviceModuleDefault : public T {
  bool BuiltInAGCIsAvailable() const override { return false; }
  int32_t EnableBuiltInAGC(bool /* enable */) override { return -1; }
  bool BuiltInNSIsAvailable() const override { return false; }
-  int32_t EnableBuiltInNS(bool enable) override { return -1; }
+  int32_t EnableBuiltInNS(bool /* enable */) override { return -1; }

  int32_t GetPlayoutUnderrunCount() const override { return -1; }

--- a/modules/audio_device/include/test_audio_device.cc
+++ b/modules/audio_device/include/test_audio_device.cc
@ -287,7 +287,9 @@ class DiscardRenderer final : public TestAudioDeviceModule::Renderer {

  int NumChannels() const override { return num_channels_; }

-  bool Render(rtc::ArrayView<const int16_t> data) override { return true; }
+  bool Render(rtc::ArrayView<const int16_t> /* data */) override {
+    return true;
+  }

 private:
  int sampling_frequency_in_hz_;
--- a/modules/audio_device/test_audio_device_impl_test.cc
+++ b/modules/audio_device/test_audio_device_impl_test.cc
@ -42,17 +42,17 @@ class TestAudioTransport : public AudioTransport {
  ~TestAudioTransport() override = default;

  int32_t RecordedDataIsAvailable(
-      const void* audioSamples,
+      const void* /* audioSamples */,
      size_t samples_per_channel,
      size_t bytes_per_sample,
      size_t number_of_channels,
      uint32_t samples_per_second,
-      uint32_t total_delay_ms,
-      int32_t clock_drift,
-      uint32_t current_mic_level,
-      bool key_pressed,
+      uint32_t /* total_delay_ms */,
+      int32_t /* clock_drift */,
+      uint32_t /* current_mic_level */,
+      bool /* key_pressed */,
      uint32_t& new_mic_level,
-      std::optional<int64_t> estimated_capture_time_ns) override {
+      std::optional<int64_t> /* estimated_capture_time_ns */) override {
    new_mic_level = 1;

    if (mode_ != Mode::kRecording) {
@ -97,26 +97,26 @@ class TestAudioTransport : public AudioTransport {
    return 0;
  }

-  int32_t RecordedDataIsAvailable(const void* audio_samples,
-                                  size_t samples_per_channel,
-                                  size_t bytes_per_sample,
-                                  size_t number_of_channels,
-                                  uint32_t samples_per_second,
-                                  uint32_t total_delay_ms,
-                                  int32_t clockDrift,
-                                  uint32_t current_mic_level,
-                                  bool key_pressed,
-                                  uint32_t& new_mic_level) override {
+  int32_t RecordedDataIsAvailable(const void* /* audio_samples */,
+                                  size_t /* samples_per_channel */,
+                                  size_t /* bytes_per_sample */,
+                                  size_t /* number_of_channels */,
+                                  uint32_t /* samples_per_second */,
+                                  uint32_t /* total_delay_ms */,
+                                  int32_t /* clockDrift */,
+                                  uint32_t /* current_mic_level */,
+                                  bool /* key_pressed */,
+                                  uint32_t& /* new_mic_level */) override {
    RTC_CHECK(false) << "This methods should be never executed";
  }

-  void PullRenderData(int bits_per_sample,
-                      int sample_rate,
-                      size_t number_of_channels,
-                      size_t number_of_frames,
-                      void* audio_data,
-                      int64_t* elapsed_time_ms,
-                      int64_t* ntp_time_ms) override {
+  void PullRenderData(int /* bits_per_sample */,
+                      int /* sample_rate */,
+                      size_t /* number_of_channels */,
+                      size_t /* number_of_frames */,
+                      void* /* audio_data */,
+                      int64_t* /* elapsed_time_ms */,
+                      int64_t* /* ntp_time_ms */) override {
    RTC_CHECK(false) << "This methods should be never executed";
  }

--- a/modules/audio_processing/aec3/echo_canceller3_unittest.cc
+++ b/modules/audio_processing/aec3/echo_canceller3_unittest.cc
@ -164,9 +164,9 @@ class RenderTransportVerificationProcessor : public BlockProcessor {

  void GetMetrics(EchoControl::Metrics* /* metrics */) const override {}

-  void SetAudioBufferDelay(int delay_ms) override {}
+  void SetAudioBufferDelay(int /* delay_ms */) override {}

-  void SetCaptureOutputUsage(bool capture_output_used) {}
+  void SetCaptureOutputUsage(bool /* capture_output_used */) {}

 private:
  std::deque<Block> received_render_blocks_;
--- a/modules/pacing/packet_router_unittest.cc
+++ b/modules/pacing/packet_router_unittest.cc
@ -298,7 +298,7 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
  RtpRtcpInterface* last_send_module;
  EXPECT_CALL(rtp_1, GeneratePadding(kPaddingBytes))
      .Times(1)
-      .WillOnce([&](size_t target_size_bytes) {
+      .WillOnce([&](size_t /* target_size_bytes */) {
        last_send_module = &rtp_1;
        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
        packets.push_back(BuildRtpPacket(kSsrc1));
@ -306,7 +306,7 @@ TEST_F(PacketRouterTest, PadsOnLastActiveMediaStream) {
      });
  EXPECT_CALL(rtp_3, GeneratePadding(kPaddingBytes))
      .Times(1)
-      .WillOnce([&](size_t target_size_bytes) {
+      .WillOnce([&](size_t /* target_size_bytes */) {
        last_send_module = &rtp_3;
        std::vector<std::unique_ptr<RtpPacketToSend>> packets;
        packets.push_back(BuildRtpPacket(kSsrc3));
@ -371,7 +371,7 @@ TEST_F(PacketRouterTest, AllocatesTransportSequenceNumbers) {
  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
  EXPECT_CALL(notify_bwe_callback, Call)
      .WillOnce([](const RtpPacketToSend& packet,
-                   const PacedPacketInfo& pacing_info) {
+                   const PacedPacketInfo& /* pacing_info */) {
        EXPECT_EQ(packet.transport_sequence_number(), 1);
      });
  packet_router.SendPacket(std::move(packet), PacedPacketInfo());
@ -442,9 +442,8 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
  // Return failure status code to make sure sequence number is not incremented.
  auto packet = BuildRtpPacket(kSsrc);
  EXPECT_TRUE(packet->ReserveExtension<TransportSequenceNumber>());
-  EXPECT_CALL(rtp, CanSendPacket).WillOnce([&](const RtpPacketToSend& packet) {
-    return false;
-  });
+  EXPECT_CALL(rtp, CanSendPacket)
+      .WillOnce([&](const RtpPacketToSend& /* packet */) { return false; });
  packet_router_.SendPacket(std::move(packet), PacedPacketInfo());

  // Send another packet, verify transport sequence number is still at the
@ -455,7 +454,7 @@ TEST_F(PacketRouterTest, DoesNotIncrementTransportSequenceNumberOnSendFailure) {
  EXPECT_CALL(rtp, CanSendPacket).WillOnce(Return(true));
  EXPECT_CALL(rtp, SendPacket)
      .WillOnce([&](std::unique_ptr<RtpPacketToSend> packet,
-                    const PacedPacketInfo& pacing_info) {
+                    const PacedPacketInfo& /* pacing_info */) {
        EXPECT_EQ(packet->transport_sequence_number(),
                  kStartTransportSequenceNumber);
      });
--- a/modules/pacing/task_queue_paced_sender_unittest.cc
+++ b/modules/pacing/task_queue_paced_sender_unittest.cc
@ -142,8 +142,8 @@ TEST(TaskQueuePacedSenderTest, PacesPackets) {
  size_t packets_sent = 0;
  Timestamp end_time = Timestamp::PlusInfinity();
  EXPECT_CALL(packet_router, SendPacket)
-      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
-                          const PacedPacketInfo& cluster_info) {
+      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
+                          const PacedPacketInfo& /* cluster_info */) {
        ++packets_sent;
        if (packets_sent == kPacketsToSend) {
          end_time = time_controller.GetClock()->CurrentTime();
@ -188,8 +188,8 @@ TEST(TaskQueuePacedSenderTest, PacesPacketsWithBurst) {
  size_t packets_sent = 0;
  Timestamp end_time = Timestamp::PlusInfinity();
  EXPECT_CALL(packet_router, SendPacket)
-      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
-                          const PacedPacketInfo& cluster_info) {
+      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
+                          const PacedPacketInfo& /* cluster_info */) {
        ++packets_sent;
        if (packets_sent == kPacketsToSend) {
          end_time = time_controller.GetClock()->CurrentTime();
@ -240,7 +240,7 @@ TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {

  EXPECT_CALL(packet_router, SendPacket)
      .Times(3)
-      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> packet,
+      .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
                          const PacedPacketInfo& cluster_info) {
        if (first_packet_time.IsInfinite()) {
          first_packet_time = time_controller.GetClock()->CurrentTime();
--- a/modules/remote_bitrate_estimator/congestion_control_feedback_generator_unittest.cc
+++ b/modules/remote_bitrate_estimator/congestion_control_feedback_generator_unittest.cc
@ -40,11 +40,12 @@ using ::testing::MockFunction;
 using ::testing::SizeIs;
 using ::testing::WithoutArgs;

-RtpPacketReceived CreatePacket(Timestamp arrival_time,
-                               bool marker,
-                               uint32_t ssrc = 1234,
-                               uint16_t seq = 1,
-                               rtc::EcnMarking ecn = rtc::EcnMarking::kNotEct) {
+RtpPacketReceived CreatePacket(
+    Timestamp arrival_time,
+    bool marker,
+    uint32_t ssrc = 1234,
+    uint16_t seq = 1,
+    rtc::EcnMarking /* ecn */ = rtc::EcnMarking::kNotEct) {
  RtpPacketReceived packet;
  packet.SetSsrc(ssrc);
  packet.SetSequenceNumber(seq);
--- a/modules/remote_bitrate_estimator/overuse_estimator.cc
+++ b/modules/remote_bitrate_estimator/overuse_estimator.cc
@ -32,7 +32,7 @@ void OveruseEstimator::Update(int64_t t_delta,
                              double ts_delta,
                              int size_delta,
                              BandwidthUsage current_hypothesis,
-                              int64_t now_ms) {
+                              int64_t /* now_ms */) {
  const double min_frame_period = UpdateMinFramePeriod(ts_delta);
  const double t_ts_delta = t_delta - ts_delta;
  double fs_delta = size_delta;
--- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
@ -164,7 +164,7 @@ void RemoteBitrateEstimatorSingleStream::UpdateEstimate(Timestamp now) {
 }

 void RemoteBitrateEstimatorSingleStream::OnRttUpdate(int64_t avg_rtt_ms,
-                                                     int64_t max_rtt_ms) {
+                                                     int64_t /* max_rtt_ms */) {
  remote_rate_.SetRtt(TimeDelta::Millis(avg_rtt_ms));
 }

--- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc
@ -29,7 +29,7 @@ const int kNumInitialPackets = 2;
 namespace testing {

 void TestBitrateObserver::OnReceiveBitrateChanged(
-    const std::vector<uint32_t>& ssrcs,
+    const std::vector<uint32_t>& /* ssrcs */,
    uint32_t bitrate) {
  latest_bitrate_ = bitrate;
  updated_ = true;
@ -251,7 +251,7 @@ void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
 // Returns true if an over-use was seen, false otherwise.
 // The StreamGenerator::updated() should be used to check for any changes in
 // target bitrate after the call to this function.
-bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t ssrc,
+bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t /* ssrc */,
                                                         uint32_t bitrate_bps) {
  RTC_DCHECK_GT(bitrate_bps, 0);
  stream_generator_->SetBitrateBps(bitrate_bps);
--- a/modules/rtp_rtcp/source/absolute_capture_time_interpolator.cc
+++ b/modules/rtp_rtcp/source/absolute_capture_time_interpolator.cc
@ -81,7 +81,7 @@ uint64_t AbsoluteCaptureTimeInterpolator::InterpolateAbsoluteCaptureTimestamp(
 bool AbsoluteCaptureTimeInterpolator::ShouldInterpolateExtension(
    Timestamp receive_time,
    uint32_t source,
-    uint32_t rtp_timestamp,
+    uint32_t /* rtp_timestamp */,
    int rtp_clock_frequency_hz) const {
  // Shouldn't if the last received extension is not eligible for interpolation,
  // in particular if we don't have a previously received extension stored.
--- a/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.h
+++ b/modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.h
@ -45,7 +45,7 @@ class DEPRECATED_RtpSenderEgress {

    void EnqueuePackets(
        std::vector<std::unique_ptr<RtpPacketToSend>> packets) override;
-    void RemovePacketsForSsrc(uint32_t ssrc) override {}
+    void RemovePacketsForSsrc(uint32_t /* ssrc */) override {}

   private:
    uint16_t transport_sequence_number_;
--- a/modules/rtp_rtcp/source/forward_error_correction.cc
+++ b/modules/rtp_rtcp/source/forward_error_correction.cc
@ -571,7 +571,7 @@ bool ForwardErrorCorrection::StartPacketRecovery(
 }

 bool ForwardErrorCorrection::FinishPacketRecovery(
-    const ReceivedFecPacket& fec_packet,
+    const ReceivedFecPacket& /* fec_packet */,
    RecoveredPacket* recovered_packet) {
  uint8_t* data = recovered_packet->pkt->data.MutableData();
  // Set the RTP version to 2.
--- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@ -78,7 +78,7 @@ class RtxLoopBackTransport : public webrtc::Transport {
  }

  bool SendRtp(rtc::ArrayView<const uint8_t> data,
-               const PacketOptions& options) override {
+               const PacketOptions& /* options */) override {
    count_++;
    RtpPacketReceived packet;
    if (!packet.Parse(data))
--- a/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender.cc
@ -221,7 +221,7 @@ bool RTCPSender::Sending() const {
  return sending_;
 }

-void RTCPSender::SetSendingStatus(const FeedbackState& feedback_state,
+void RTCPSender::SetSendingStatus(const FeedbackState& /* feedback_state */,
                                  bool sending) {
  MutexLock lock(&mutex_rtcp_sender_);
  sending_ = sending;
@ -404,7 +404,7 @@ void RTCPSender::BuildSR(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(report);
 }

-void RTCPSender::BuildSDES(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildSDES(const RtcpContext& /* ctx */, PacketSender& sender) {
  size_t length_cname = cname_.length();
  RTC_CHECK_LT(length_cname, RTCP_CNAME_SIZE);

@ -422,7 +422,7 @@ void RTCPSender::BuildRR(const RtcpContext& ctx, PacketSender& sender) {
  }
 }

-void RTCPSender::BuildPLI(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildPLI(const RtcpContext& /* ctx */, PacketSender& sender) {
  rtcp::Pli pli;
  pli.SetSenderSsrc(ssrc_);
  pli.SetMediaSsrc(remote_ssrc_);
@ -431,7 +431,7 @@ void RTCPSender::BuildPLI(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(pli);
 }

-void RTCPSender::BuildFIR(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildFIR(const RtcpContext& /* ctx */, PacketSender& sender) {
  ++sequence_number_fir_;

  rtcp::Fir fir;
@ -442,7 +442,7 @@ void RTCPSender::BuildFIR(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(fir);
 }

-void RTCPSender::BuildREMB(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildREMB(const RtcpContext& /* ctx */, PacketSender& sender) {
  rtcp::Remb remb;
  remb.SetSenderSsrc(ssrc_);
  remb.SetBitrateBps(remb_bitrate_);
@ -509,7 +509,8 @@ void RTCPSender::BuildTMMBR(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(tmmbr);
 }

-void RTCPSender::BuildTMMBN(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildTMMBN(const RtcpContext& /* ctx */,
+                            PacketSender& sender) {
  rtcp::Tmmbn tmmbn;
  tmmbn.SetSenderSsrc(ssrc_);
  for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) {
@ -520,13 +521,13 @@ void RTCPSender::BuildTMMBN(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(tmmbn);
 }

-void RTCPSender::BuildAPP(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildAPP(const RtcpContext& /* ctx */, PacketSender& sender) {
  rtcp::App app;
  app.SetSenderSsrc(ssrc_);
  sender.AppendPacket(app);
 }

-void RTCPSender::BuildLossNotification(const RtcpContext& ctx,
+void RTCPSender::BuildLossNotification(const RtcpContext& /* ctx */,
                                       PacketSender& sender) {
  loss_notification_.SetSenderSsrc(ssrc_);
  loss_notification_.SetMediaSsrc(remote_ssrc_);
@ -550,7 +551,7 @@ void RTCPSender::BuildNACK(const RtcpContext& ctx, PacketSender& sender) {
  sender.AppendPacket(nack);
 }

-void RTCPSender::BuildBYE(const RtcpContext& ctx, PacketSender& sender) {
+void RTCPSender::BuildBYE(const RtcpContext& /* ctx */, PacketSender& sender) {
  rtcp::Bye bye;
  bye.SetSenderSsrc(ssrc_);
  bye.SetCsrcs(csrcs_);
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@ -78,7 +78,7 @@ class TestTransport : public Transport {
  TestTransport() {}

  bool SendRtp(rtc::ArrayView<const uint8_t> /*data*/,
-               const PacketOptions& options) override {
+               const PacketOptions& /* options */) override {
    return false;
  }
  bool SendRtcp(rtc::ArrayView<const uint8_t> data) override {
--- a/modules/rtp_rtcp/source/rtcp_transceiver_config.h
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_config.h
@ -34,12 +34,13 @@ class MediaReceiverRtcpObserver {
 public:
  virtual ~MediaReceiverRtcpObserver() = default;

-  virtual void OnSenderReport(uint32_t sender_ssrc,
-                              NtpTime ntp_time,
-                              uint32_t rtp_time) {}
-  virtual void OnBye(uint32_t sender_ssrc) {}
-  virtual void OnBitrateAllocation(uint32_t sender_ssrc,
-                                   const VideoBitrateAllocation& allocation) {}
+  virtual void OnSenderReport(uint32_t /* sender_ssrc */,
+                              NtpTime /* ntp_time */,
+                              uint32_t /* rtp_time */) {}
+  virtual void OnBye(uint32_t /* sender_ssrc */) {}
+  virtual void OnBitrateAllocation(
+      uint32_t /* sender_ssrc */,
+      const VideoBitrateAllocation& /* allocation */) {}
 };

 // Handles RTCP related messages for a single RTP stream (i.e. single SSRC)
@ -76,14 +77,14 @@ class RtpStreamRtcpHandler {
  };
  virtual RtpStats SentStats() = 0;

-  virtual void OnNack(uint32_t sender_ssrc,
-                      rtc::ArrayView<const uint16_t> sequence_numbers) {}
-  virtual void OnFir(uint32_t sender_ssrc) {}
-  virtual void OnPli(uint32_t sender_ssrc) {}
+  virtual void OnNack(uint32_t /* sender_ssrc */,
+                      rtc::ArrayView<const uint16_t> /* sequence_numbers */) {}
+  virtual void OnFir(uint32_t /* sender_ssrc */) {}
+  virtual void OnPli(uint32_t /* sender_ssrc */) {}

  // Called on an RTCP packet with sender or receiver reports with a report
  // block for the handled RTP stream.
-  virtual void OnReport(const ReportBlockData& report_block) {}
+  virtual void OnReport(const ReportBlockData& /* report_block */) {}
 };

 struct RtcpTransceiverConfig {
--- a/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_impl.cc
@ -56,7 +56,8 @@ std::function<void(rtc::ArrayView<const uint8_t>)> GetRtcpTransport(

  bool first = true;
  std::string log_prefix = config.debug_id;
-  return [first, log_prefix](rtc::ArrayView<const uint8_t> packet) mutable {
+  return [first,
+          log_prefix](rtc::ArrayView<const uint8_t> /* packet */) mutable {
    if (first) {
      RTC_LOG(LS_ERROR) << log_prefix << "Sending RTCP packets is disabled.";
      first = false;
--- a/modules/rtp_rtcp/source/rtp_fec_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_fec_unittest.cc
@ -184,7 +184,7 @@ class FlexfecForwardErrorCorrection : public ForwardErrorCorrection {

  // For FlexFEC we let the FEC packet sequence numbers be independent of
  // the media packet sequence numbers.
-  static uint16_t GetFirstFecSeqNum(uint16_t next_media_seq_num) {
+  static uint16_t GetFirstFecSeqNum(uint16_t /* next_media_seq_num */) {
    Random random(0xbe110);
    return random.Rand<uint16_t>();
  }
--- a/modules/rtp_rtcp/source/rtp_header_extensions.h
+++ b/modules/rtp_rtcp/source/rtp_header_extensions.h
@ -48,7 +48,9 @@ class AbsoluteSendTime {
  }

  static bool Parse(rtc::ArrayView<const uint8_t> data, uint32_t* time_24bits);
-  static size_t ValueSize(uint32_t time_24bits) { return kValueSizeBytes; }
+  static size_t ValueSize(uint32_t /* time_24bits */) {
+    return kValueSizeBytes;
+  }
  static bool Write(rtc::ArrayView<uint8_t> data, uint32_t time_24bits);

  static constexpr uint32_t To24Bits(Timestamp time) {
@ -98,7 +100,7 @@ class AudioLevelExtension {
  }

  static bool Parse(rtc::ArrayView<const uint8_t> data, AudioLevel* extension);
-  static size_t ValueSize(const AudioLevel& extension) {
+  static size_t ValueSize(const AudioLevel& /* extension */) {
    return kValueSizeBytes;
  }
  static bool Write(rtc::ArrayView<uint8_t> data, const AudioLevel& extension);
@ -129,7 +131,7 @@ class TransmissionOffset {
  }

  static bool Parse(rtc::ArrayView<const uint8_t> data, int32_t* rtp_time);
-  static size_t ValueSize(int32_t rtp_time) { return kValueSizeBytes; }
+  static size_t ValueSize(int32_t /* rtp_time */) { return kValueSizeBytes; }
  static bool Write(rtc::ArrayView<uint8_t> data, int32_t rtp_time);
 };

@ -191,7 +193,7 @@ class VideoOrientation {
  static size_t ValueSize(VideoRotation) { return kValueSizeBytes; }
  static bool Write(rtc::ArrayView<uint8_t> data, VideoRotation value);
  static bool Parse(rtc::ArrayView<const uint8_t> data, uint8_t* value);
-  static size_t ValueSize(uint8_t value) { return kValueSizeBytes; }
+  static size_t ValueSize(uint8_t /* value */) { return kValueSizeBytes; }
  static bool Write(rtc::ArrayView<uint8_t> data, uint8_t value);
 };

@ -259,7 +261,7 @@ class VideoTimingExtension {
  static bool Write(rtc::ArrayView<uint8_t> data,
                    const VideoSendTiming& timing);

-  static size_t ValueSize(uint16_t time_delta_ms, uint8_t idx) {
+  static size_t ValueSize(uint16_t /* time_delta_ms */, uint8_t /* idx */) {
    return kValueSizeBytes;
  }
  // Writes only single time delta to position idx.
@ -354,7 +356,7 @@ class InbandComfortNoiseExtension {

  static bool Parse(rtc::ArrayView<const uint8_t> data,
                    std::optional<uint8_t>* level);
-  static size_t ValueSize(std::optional<uint8_t> level) {
+  static size_t ValueSize(std::optional<uint8_t> /* level */) {
    return kValueSizeBytes;
  }
  static bool Write(rtc::ArrayView<uint8_t> data, std::optional<uint8_t> level);
--- a/modules/rtp_rtcp/source/rtp_packet_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
@ -874,13 +874,13 @@ struct UncopyableExtension {
  static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor;
  static constexpr absl::string_view Uri() { return "uri"; }

-  static size_t ValueSize(const UncopyableValue& value) { return 1; }
-  static bool Write(rtc::ArrayView<uint8_t> data,
-                    const UncopyableValue& value) {
+  static size_t ValueSize(const UncopyableValue& /* value */) { return 1; }
+  static bool Write(rtc::ArrayView<uint8_t> /* data */,
+                    const UncopyableValue& /* value */) {
    return true;
  }
-  static bool Parse(rtc::ArrayView<const uint8_t> data,
-                    UncopyableValue* value) {
+  static bool Parse(rtc::ArrayView<const uint8_t> /* data */,
+                    UncopyableValue* /* value */) {
    return true;
  }
 };
@ -909,7 +909,9 @@ struct ParseByReferenceExtension {
  static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor;
  static constexpr absl::string_view Uri() { return "uri"; }

-  static size_t ValueSize(uint8_t value1, uint8_t value2) { return 2; }
+  static size_t ValueSize(uint8_t /* value1 */, uint8_t /* value2 */) {
+    return 2;
+  }
  static bool Write(rtc::ArrayView<uint8_t> data,
                    uint8_t value1,
                    uint8_t value2) {
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@ -219,7 +219,8 @@ void ModuleRtpRtcpImpl::RegisterSendPayloadFrequency(int payload_type,
  rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency);
 }

-int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
+int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(
+    const int8_t /* payload_type */) {
  return 0;
 }

@ -402,7 +403,7 @@ ModuleRtpRtcpImpl::FetchFecPackets() {
 }

 void ModuleRtpRtcpImpl::OnAbortedRetransmissions(
-    rtc::ArrayView<const uint16_t> sequence_numbers) {
+    rtc::ArrayView<const uint16_t> /* sequence_numbers */) {
  RTC_DCHECK_NOTREACHED()
      << "Stream flushing not supported with legacy rtp modules.";
 }
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@ -103,7 +103,7 @@ class ABSL_DEPRECATED("") ModuleRtpRtcpImpl
  RtpState GetRtpState() const override;
  RtpState GetRtxState() const override;

-  void SetNonSenderRttMeasurement(bool enabled) override {}
+  void SetNonSenderRttMeasurement(bool /* enabled */) override {}

  uint32_t SSRC() const override { return rtcp_sender_.SSRC(); }

@ -142,17 +142,17 @@ class ABSL_DEPRECATED("") ModuleRtpRtcpImpl
  bool TrySendPacket(std::unique_ptr<RtpPacketToSend> packet,
                     const PacedPacketInfo& pacing_info) override;

-  bool CanSendPacket(const RtpPacketToSend& packet) const override {
+  bool CanSendPacket(const RtpPacketToSend& /* packet */) const override {
    RTC_DCHECK_NOTREACHED() << "Not implemented";
    return false;
  }

-  void AssignSequenceNumber(RtpPacketToSend& packet) override {
+  void AssignSequenceNumber(RtpPacketToSend& /* packet */) override {
    RTC_DCHECK_NOTREACHED() << "Not implemented";
  }

-  void SendPacket(std::unique_ptr<RtpPacketToSend> packet,
-                  const PacedPacketInfo& pacing_info) override {
+  void SendPacket(std::unique_ptr<RtpPacketToSend> /* packet */,
+                  const PacedPacketInfo& /* pacing_info */) override {
    RTC_DCHECK_NOTREACHED() << "Not implemented";
  }

--- a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
@ -169,7 +169,8 @@ void ModuleRtpRtcpImpl2::RegisterSendPayloadFrequency(int payload_type,
  rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency);
 }

-int32_t ModuleRtpRtcpImpl2::DeRegisterSendPayload(const int8_t payload_type) {
+int32_t ModuleRtpRtcpImpl2::DeRegisterSendPayload(
+    const int8_t /* payload_type */) {
  return 0;
 }

--- a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
@ -104,7 +104,7 @@ class SendTransport : public Transport,
  void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
  void SimulateNetworkDelay(TimeDelta delay) { delay_ = delay; }
  bool SendRtp(rtc::ArrayView<const uint8_t> data,
-               const PacketOptions& options) override {
+               const PacketOptions& /* options */) override {
    EXPECT_TRUE(last_packet_.Parse(data));
    ++rtp_packets_sent_;
    return true;
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@ -96,7 +96,7 @@ class SendTransport : public Transport {
    delay_ms_ = delay_ms;
  }
  bool SendRtp(rtc::ArrayView<const uint8_t> data,
-               const PacketOptions& options) override {
+               const PacketOptions& /* options */) override {
    RtpPacket packet;
    EXPECT_TRUE(packet.Parse(data));
    ++rtp_packets_sent_;
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@ -327,7 +327,8 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
  return packet_size;
 }

-void RTPSender::OnReceivedAckOnSsrc(int64_t extended_highest_sequence_number) {
+void RTPSender::OnReceivedAckOnSsrc(
+    int64_t /* extended_highest_sequence_number */) {
  MutexLock lock(&send_mutex_);
  bool update_required = !ssrc_has_acked_;
  ssrc_has_acked_ = true;
@ -337,7 +338,7 @@ void RTPSender::OnReceivedAckOnSsrc(int64_t extended_highest_sequence_number) {
 }

 void RTPSender::OnReceivedAckOnRtxSsrc(
-    int64_t extended_highest_sequence_number) {
+    int64_t /* extended_highest_sequence_number */) {
  MutexLock lock(&send_mutex_);
  bool update_required = !rtx_ssrc_has_acked_;
  rtx_ssrc_has_acked_ = true;
--- a/modules/rtp_rtcp/source/rtp_sender_audio.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc
@ -47,8 +47,8 @@ RTPSenderAudio::~RTPSenderAudio() {}
 int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name,
                                             const int8_t payload_type,
                                             const uint32_t frequency,
-                                             const size_t channels,
-                                             const uint32_t rate) {
+                                             const size_t /* channels */,
+                                             const uint32_t /* rate */) {
  if (absl::EqualsIgnoreCase(payload_name, "cn")) {
    MutexLock lock(&send_audio_mutex_);
    //  we can have multiple CNG payload types
--- a/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
@ -52,7 +52,9 @@ class LoopbackTransportTest : public webrtc::Transport {
    EXPECT_TRUE(sent_packets_.back().Parse(data));
    return true;
  }
-  bool SendRtcp(rtc::ArrayView<const uint8_t> data) override { return false; }
+  bool SendRtcp(rtc::ArrayView<const uint8_t> /* data */) override {
+    return false;
+  }
  const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
  int packets_sent() { return sent_packets_.size(); }

--- a/modules/rtp_rtcp/source/rtp_sender_egress.h
+++ b/modules/rtp_rtcp/source/rtp_sender_egress.h
@ -54,7 +54,7 @@ class RtpSenderEgress {
    void EnqueuePackets(
        std::vector<std::unique_ptr<RtpPacketToSend>> packets) override;
    // Since we don't pace packets, there's no pending packets to remove.
-    void RemovePacketsForSsrc(uint32_t ssrc) override {}
+    void RemovePacketsForSsrc(uint32_t /* ssrc */) override {}

   private:
    void PrepareForSend(RtpPacketToSend* packet);
--- a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
@ -123,12 +123,14 @@ class LoopbackTransportTest : public webrtc::Transport {
  }

  bool SendRtp(rtc::ArrayView<const uint8_t> data,
-               const PacketOptions& options) override {
+               const PacketOptions& /* options */) override {
    sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_));
    EXPECT_TRUE(sent_packets_.back().Parse(data));
    return true;
  }
-  bool SendRtcp(rtc::ArrayView<const uint8_t> data) override { return false; }
+  bool SendRtcp(rtc::ArrayView<const uint8_t> /* data */) override {
+    return false;
+  }
  const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
  int packets_sent() { return sent_packets_.size(); }
  const std::vector<RtpPacketReceived>& sent_packets() const {
@ -969,7 +971,7 @@ TEST_F(RtpSenderVideoTest, PopulateGenericFrameDescriptor) {

 void RtpSenderVideoTest::
    UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed(
-        int version) {
+        int /* version */) {
  const int64_t kFrameId = 100000;
  const size_t kFrameSize = 100;
  uint8_t kFrame[kFrameSize];
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
@ -98,7 +98,7 @@ UlpfecHeaderWriter::~UlpfecHeaderWriter() = default;
 // returns a bound on the sequence number spread), if logic is added to
 // UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end
 // in a string of zeroes. (Similar to how it is done in the FlexFEC case.)
-size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask,
+size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* /* packet_mask */,
                                             size_t packet_mask_size) const {
  return packet_mask_size;
 }
--- a/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
@ -41,7 +41,7 @@ constexpr uint32_t kMediaSsrc = 835424;

 class NullRecoveredPacketReceiver : public RecoveredPacketReceiver {
 public:
-  void OnRecoveredPacket(const RtpPacketReceived& packet) override {}
+  void OnRecoveredPacket(const RtpPacketReceived& /* packet */) override {}
 };

 }  // namespace
--- a/modules/rtp_rtcp/test/testFec/test_packet_masks_metrics.cc
+++ b/modules/rtp_rtcp/test/testFec/test_packet_masks_metrics.cc
@ -693,7 +693,7 @@ class FecPacketMaskMetricsTest : public ::testing::Test {
                                     int num_media_packets,
                                     int num_fec_packets,
                                     int mask_bytes_fec_packet,
-                                     CodeType code_type) {
+                                     CodeType /* code_type */) {
    for (int i = 0; i < num_fec_packets; i++) {
      for (int j = 0; j < num_media_packets; j++) {
        const uint8_t byte_mask =
--- a/modules/video_capture/device_info_impl.cc
+++ b/modules/video_capture/device_info_impl.cc
@ -202,7 +202,7 @@ int32_t DeviceInfoImpl::GetBestMatchedCapability(
 }

 // Default implementation. This should be overridden by Mobile implementations.
-int32_t DeviceInfoImpl::GetOrientation(const char* deviceUniqueIdUTF8,
+int32_t DeviceInfoImpl::GetOrientation(const char* /* deviceUniqueIdUTF8 */,
                                       VideoRotation& orientation) {
  orientation = kVideoRotation_0;
  return -1;
--- a/modules/video_capture/video_capture_factory.cc
+++ b/modules/video_capture/video_capture_factory.cc
@ -15,7 +15,7 @@
 namespace webrtc {

 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
-    const char* deviceUniqueIdUTF8) {
+    [[maybe_unused]] const char* deviceUniqueIdUTF8) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
  return nullptr;
 #else
@ -24,8 +24,8 @@ rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
 }

 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureFactory::Create(
-    VideoCaptureOptions* options,
-    const char* deviceUniqueIdUTF8) {
+    [[maybe_unused]] VideoCaptureOptions* options,
+    [[maybe_unused]] const char* deviceUniqueIdUTF8) {
 // This is only implemented on pure Linux and WEBRTC_LINUX is defined for
 // Android as well
 #if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID)
@ -45,7 +45,7 @@ VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo() {
 }

 VideoCaptureModule::DeviceInfo* VideoCaptureFactory::CreateDeviceInfo(
-    VideoCaptureOptions* options) {
+    [[maybe_unused]] VideoCaptureOptions* options) {
 // This is only implemented on pure Linux and WEBRTC_LINUX is defined for
 // Android as well
 #if !defined(WEBRTC_LINUX) || defined(WEBRTC_ANDROID)
--- a/modules/video_coding/codecs/av1/dav1d_decoder.cc
+++ b/modules/video_coding/codecs/av1/dav1d_decoder.cc
@ -72,7 +72,7 @@ class ScopedDav1dPicture
 constexpr char kDav1dName[] = "dav1d";

 // Calling `dav1d_data_wrap` requires a `free_callback` to be registered.
-void NullFreeCallback(const uint8_t* buffer, void* opaque) {}
+void NullFreeCallback(const uint8_t* /* buffer */, void* /* opaque */) {}

 Dav1dDecoder::Dav1dDecoder() = default;

--- a/modules/video_coding/codecs/av1/libaom_av1_encoder_unittest.cc
+++ b/modules/video_coding/codecs/av1/libaom_av1_encoder_unittest.cc
@ -415,7 +415,7 @@ TEST(LibaomAv1EncoderTest, AdheresToTargetBitrateDespiteUnevenFrameTiming) {
   private:
    Result OnEncodedImage(
        const EncodedImage& encoded_image,
-        const CodecSpecificInfo* codec_specific_info) override {
+        const CodecSpecificInfo* /* codec_specific_info */) override {
      bytes_encoded_ += DataSize::Bytes(encoded_image.size());
      return Result(Result::Error::OK);
    }
--- a/modules/video_coding/codecs/h264/h264.cc
+++ b/modules/video_coding/codecs/h264/h264.cc
@ -134,8 +134,8 @@ H264EncoderSettings H264EncoderSettings::Parse(const SdpVideoFormat& format) {
 }

 absl::Nonnull<std::unique_ptr<VideoEncoder>> CreateH264Encoder(
-    const Environment& env,
-    H264EncoderSettings settings) {
+    [[maybe_unused]] const Environment& env,
+    [[maybe_unused]] H264EncoderSettings settings) {
 #if defined(WEBRTC_USE_H264)
  RTC_CHECK(g_rtc_use_h264);
  RTC_LOG(LS_INFO) << "Creating H264EncoderImpl.";
--- a/modules/video_coding/codecs/test/video_codec_unittest.cc
+++ b/modules/video_coding/codecs/test/video_codec_unittest.cc
@ -57,7 +57,7 @@ VideoCodecUnitTest::FakeEncodeCompleteCallback::OnEncodedImage(

 void VideoCodecUnitTest::FakeDecodeCompleteCallback::Decoded(
    VideoFrame& frame,
-    std::optional<int32_t> decode_time_ms,
+    std::optional<int32_t> /* decode_time_ms */,
    std::optional<uint8_t> qp) {
  MutexLock lock(&test_->decoded_frame_section_);
  test_->decoded_frame_.emplace(frame);
@ -97,7 +97,8 @@ void VideoCodecUnitTest::SetUp() {
  EXPECT_TRUE(decoder_->Configure(decoder_settings));
 }

-void VideoCodecUnitTest::ModifyCodecSettings(VideoCodec* codec_settings) {}
+void VideoCodecUnitTest::ModifyCodecSettings(VideoCodec* /* codec_settings */) {
+}

 VideoFrame VideoCodecUnitTest::NextInputFrame() {
  test::FrameGeneratorInterface::VideoFrameData frame_data =
--- a/modules/video_coding/codecs/test/video_codec_unittest.h
+++ b/modules/video_coding/codecs/test/video_codec_unittest.h
@ -56,11 +56,12 @@ class VideoCodecUnitTest : public ::testing::Test {
    explicit FakeDecodeCompleteCallback(VideoCodecUnitTest* test)
        : test_(test) {}

-    int32_t Decoded(VideoFrame& frame) override {
+    int32_t Decoded(VideoFrame& /* frame */) override {
      RTC_DCHECK_NOTREACHED();
      return -1;
    }
-    int32_t Decoded(VideoFrame& frame, int64_t decode_time_ms) override {
+    int32_t Decoded(VideoFrame& /* frame */,
+                    int64_t /* decode_time_ms */) override {
      RTC_DCHECK_NOTREACHED();
      return -1;
    }
--- a/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
@ -364,7 +364,7 @@ TEST(VideoCodecTestLibvpx, MAYBE_SimulcastVP8) {

  InternalEncoderFactory internal_encoder_factory;
  auto adapted_encoder_factory = std::make_unique<FunctionVideoEncoderFactory>(
-      [&](const Environment& env, const SdpVideoFormat& format) {
+      [&](const Environment& env, const SdpVideoFormat& /* format */) {
        return std::make_unique<SimulcastEncoderAdapter>(
            env, &internal_encoder_factory, nullptr, SdpVideoFormat::VP8());
      });
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@ -644,8 +644,8 @@ void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image,

 const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
    const EncodedImage& encoded_image,
-    const VideoCodecType codec,
-    size_t frame_number,
+    const VideoCodecType /* codec */,
+    size_t /* frame_number */,
    size_t spatial_idx,
    bool inter_layer_predicted) {
  // Should only be called for SVC.
--- a/modules/video_coding/codecs/test/videoprocessor.h
+++ b/modules/video_coding/codecs/test/videoprocessor.h
@ -141,13 +141,13 @@ class VideoProcessor {
    int32_t Decoded(webrtc::VideoFrame& image) override;

    int32_t Decoded(webrtc::VideoFrame& image,
-                    int64_t decode_time_ms) override {
+                    int64_t /* decode_time_ms */) override {
      return Decoded(image);
    }

    void Decoded(webrtc::VideoFrame& image,
-                 std::optional<int32_t> decode_time_ms,
-                 std::optional<uint8_t> qp) override {
+                 std::optional<int32_t> /* decode_time_ms */,
+                 std::optional<uint8_t> /* qp */) override {
      Decoded(image);
    }

--- a/modules/video_coding/codecs/vp8/default_temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
@ -240,8 +240,8 @@ DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers)
 DefaultTemporalLayers::~DefaultTemporalLayers() = default;

 void DefaultTemporalLayers::SetQpLimits(size_t stream_index,
-                                        int min_qp,
-                                        int max_qp) {
+                                        int /* min_qp */,
+                                        int /* max_qp */) {
  RTC_DCHECK_LT(stream_index, StreamCount());
  // Ignore.
 }
@ -260,7 +260,7 @@ bool DefaultTemporalLayers::SupportsEncoderFrameDropping(
 void DefaultTemporalLayers::OnRatesUpdated(
    size_t stream_index,
    const std::vector<uint32_t>& bitrates_bps,
-    int framerate_fps) {
+    int /* framerate_fps */) {
  RTC_DCHECK_LT(stream_index, StreamCount());
  RTC_DCHECK_GT(bitrates_bps.size(), 0);
  RTC_DCHECK_LE(bitrates_bps.size(), num_layers_);
@ -471,7 +471,7 @@ void DefaultTemporalLayers::OnEncodeDone(size_t stream_index,
                                         uint32_t rtp_timestamp,
                                         size_t size_bytes,
                                         bool is_keyframe,
-                                         int qp,
+                                         int /* qp */,
                                         CodecSpecificInfo* info) {
  RTC_DCHECK_LT(stream_index, StreamCount());
  RTC_DCHECK_GT(num_layers_, 0);
@ -576,7 +576,7 @@ void DefaultTemporalLayers::OnEncodeDone(size_t stream_index,
  pending_frames_.pop_front();
 }

-void DefaultTemporalLayers::OnFrameDropped(size_t stream_index,
+void DefaultTemporalLayers::OnFrameDropped(size_t /* stream_index */,
                                           uint32_t rtp_timestamp) {
  CullPendingFramesBefore(rtp_timestamp);
  RTC_CHECK(!pending_frames_.empty());
@ -584,12 +584,13 @@ void DefaultTemporalLayers::OnFrameDropped(size_t stream_index,
  pending_frames_.pop_front();
 }

-void DefaultTemporalLayers::OnPacketLossRateUpdate(float packet_loss_rate) {}
+void DefaultTemporalLayers::OnPacketLossRateUpdate(
+    float /* packet_loss_rate */) {}

-void DefaultTemporalLayers::OnRttUpdate(int64_t rtt_ms) {}
+void DefaultTemporalLayers::OnRttUpdate(int64_t /* rtt_ms */) {}

 void DefaultTemporalLayers::OnLossNotification(
-    const VideoEncoder::LossNotification& loss_notification) {}
+    const VideoEncoder::LossNotification& /* loss_notification */) {}

 FrameDependencyStructure DefaultTemporalLayers::GetTemplateStructure(
    int num_layers) const {
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_simulcast_test.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_simulcast_test.cc
@ -24,12 +24,12 @@ namespace {
 std::unique_ptr<SimulcastTestFixture> CreateSpecificSimulcastTestFixture() {
  std::unique_ptr<VideoEncoderFactory> encoder_factory =
      std::make_unique<FunctionVideoEncoderFactory>(
-          [](const Environment& env, const SdpVideoFormat& format) {
+          [](const Environment& env, const SdpVideoFormat& /* format */) {
            return CreateVp8Encoder(env);
          });
  std::unique_ptr<VideoDecoderFactory> decoder_factory =
      std::make_unique<FunctionVideoDecoderFactory>(
-          [](const Environment& env, const SdpVideoFormat& format) {
+          [](const Environment& env, const SdpVideoFormat& /* format */) {
            return CreateVp8Decoder(env);
          });
  return CreateSimulcastTestFixture(std::move(encoder_factory),
--- a/modules/video_coding/codecs/vp8/screenshare_layers.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.cc
@ -410,18 +410,18 @@ void ScreenshareLayers::OnEncodeDone(size_t stream_index,
  }
 }

-void ScreenshareLayers::OnFrameDropped(size_t stream_index,
-                                       uint32_t rtp_timestamp) {
+void ScreenshareLayers::OnFrameDropped(size_t /* stream_index */,
+                                       uint32_t /* rtp_timestamp */) {
  layers_[active_layer_].state = TemporalLayer::State::kDropped;
  ++stats_.num_overshoots_;
 }

-void ScreenshareLayers::OnPacketLossRateUpdate(float packet_loss_rate) {}
+void ScreenshareLayers::OnPacketLossRateUpdate(float /* packet_loss_rate */) {}

-void ScreenshareLayers::OnRttUpdate(int64_t rtt_ms) {}
+void ScreenshareLayers::OnRttUpdate(int64_t /* rtt_ms */) {}

 void ScreenshareLayers::OnLossNotification(
-    const VideoEncoder::LossNotification& loss_notification) {}
+    const VideoEncoder::LossNotification& /* loss_notification */) {}

 FrameDependencyStructure ScreenshareLayers::GetTemplateStructure(
    int num_layers) const {
--- a/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
@ -84,7 +84,7 @@ class ScreenshareLayerTest : public ::testing::Test {
    return flags;
  }

-  int ConfigureFrame(bool key_frame) {
+  int ConfigureFrame(bool /* key_frame */) {
    tl_config_ = NextFrameConfig(0, timestamp_);
    EXPECT_EQ(0, tl_config_.encoder_layer_id)
        << "ScreenshareLayers always encodes using the bitrate allocator for "
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@ -607,7 +607,7 @@ TEST_F(TestVp8Impl, KeepsTimestampOnReencode) {

  EXPECT_CALL(*vpx, img_wrap(_, _, _, _, _, _))
      .WillOnce(Invoke([](vpx_image_t* img, vpx_img_fmt_t fmt, unsigned int d_w,
-                          unsigned int d_h, unsigned int stride_align,
+                          unsigned int d_h, unsigned int /* stride_align */,
                          unsigned char* img_data) {
        img->fmt = fmt;
        img->d_w = d_w;
@ -906,7 +906,7 @@ TEST_P(TestVp8ImplWithMaxFrameDropTrial, EnforcesMaxFrameDropInterval) {

   protected:
    Result OnEncodedImage(const EncodedImage& encoded_image,
-                          const CodecSpecificInfo* codec_specific_info) {
+                          const CodecSpecificInfo* /* codec_specific_info */) {
      Timestamp timestamp =
          Timestamp::Millis(encoded_image.RtpTimestamp() / 90);
      if (last_callback_.IsFinite()) {
--- a/modules/video_coding/codecs/vp9/libvpx_vp9_encoder.cc
+++ b/modules/video_coding/codecs/vp9/libvpx_vp9_encoder.cc
@ -1551,7 +1551,7 @@ void LibvpxVp9Encoder::FillReferenceIndices(const vpx_codec_cx_pkt& pkt,
  }
 }

-void LibvpxVp9Encoder::UpdateReferenceBuffers(const vpx_codec_cx_pkt& pkt,
+void LibvpxVp9Encoder::UpdateReferenceBuffers(const vpx_codec_cx_pkt& /* pkt */,
                                              const size_t pic_num) {
  vpx_svc_layer_id_t layer_id = {0};
  libvpx_->codec_control(encoder_, VP9E_GET_SVC_LAYER_ID, &layer_id);
--- a/modules/video_coding/deprecated/session_info.cc
+++ b/modules/video_coding/deprecated/session_info.cc
@ -420,7 +420,7 @@ bool VCMSessionInfo::HaveLastPacket() const {

 int VCMSessionInfo::InsertPacket(const VCMPacket& packet,
                                 uint8_t* frame_buffer,
-                                 const FrameData& frame_data) {
+                                 const FrameData& /* frame_data */) {
  if (packet.video_header.frame_type == VideoFrameType::kEmptyFrame) {
    // Update sequence number of an empty packet.
    // Only media packets are inserted into the packet list.
--- a/modules/video_coding/fec_controller_default.cc
+++ b/modules/video_coding/fec_controller_default.cc
@ -80,7 +80,7 @@ uint32_t FecControllerDefault::UpdateFecRates(
    uint32_t estimated_bitrate_bps,
    int actual_framerate_fps,
    uint8_t fraction_lost,
-    std::vector<bool> loss_mask_vector,
+    std::vector<bool> /* loss_mask_vector */,
    int64_t round_trip_time_ms) {
  float target_bitrate_kbps =
      static_cast<float>(estimated_bitrate_bps) / 1000.0f;
--- a/modules/video_coding/fec_controller_unittest.cc
+++ b/modules/video_coding/fec_controller_unittest.cc
@ -32,8 +32,8 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {

  class ProtectionCallback : public VCMProtectionCallback {
   public:
-    int ProtectionRequest(const FecProtectionParams* delta_params,
-                          const FecProtectionParams* key_params,
+    int ProtectionRequest(const FecProtectionParams* /* delta_params */,
+                          const FecProtectionParams* /* key_params */,
                          uint32_t* sent_video_rate_bps,
                          uint32_t* sent_nack_rate_bps,
                          uint32_t* sent_fec_rate_bps) override {
@ -42,7 +42,7 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {
      *sent_fec_rate_bps = fec_rate_bps_;
      return 0;
    }
-    void SetRetransmissionMode(int retransmission_mode) {}
+    void SetRetransmissionMode(int /* retransmission_mode */) {}

    uint32_t fec_rate_bps_ = 0;
    uint32_t nack_rate_bps_ = 0;
--- a/modules/video_coding/generic_decoder.cc
+++ b/modules/video_coding/generic_decoder.cc
@ -44,7 +44,7 @@ constexpr size_t kDecoderFrameMemoryLength = 10;
 VCMDecodedFrameCallback::VCMDecodedFrameCallback(
    VCMTiming* timing,
    Clock* clock,
-    const FieldTrialsView& field_trials,
+    const FieldTrialsView& /* field_trials */,
    CorruptionScoreCalculator* corruption_score_calculator)
    : _clock(clock),
      _timing(timing),
--- a/modules/video_coding/include/video_coding_defines.h
+++ b/modules/video_coding/include/video_coding_defines.h
@ -64,11 +64,11 @@ class VCMReceiveCallback {
  };

  // TODO: bugs.webrtc.org/358039777 - Delete this function.
-  virtual int32_t FrameToRender(VideoFrame& videoFrame,  // NOLINT
-                                std::optional<uint8_t> qp,
-                                TimeDelta decode_time,
-                                VideoContentType content_type,
-                                VideoFrameType frame_type) {
+  virtual int32_t FrameToRender(VideoFrame& /* videoFrame */,  // NOLINT
+                                std::optional<uint8_t> /* qp */,
+                                TimeDelta /* decode_time */,
+                                VideoContentType /* content_type */,
+                                VideoFrameType /* frame_type */) {
    RTC_CHECK_NOTREACHED();
    return 0;
  }
--- a/modules/video_coding/loss_notification_controller_unittest.cc
+++ b/modules/video_coding/loss_notification_controller_unittest.cc
@ -35,7 +35,7 @@ struct Packet {

 Packet CreatePacket(
    bool first_in_frame,
-    bool last_in_frame,
+    bool /* last_in_frame */,
    uint16_t seq_num,
    uint16_t frame_id,
    bool is_key_frame,
--- a/modules/video_coding/media_opt_util.cc
+++ b/modules/video_coding/media_opt_util.cc
@ -233,7 +233,7 @@ VCMNackMethod::~VCMNackMethod() {
 }

 bool VCMNackMethod::EffectivePacketLoss(
-    const VCMProtectionParameters* parameter) {
+    const VCMProtectionParameters* /* parameter */) {
  // Effective Packet Loss, NA in current version.
  _effectivePacketLoss = 0;
  return true;