Comment unused variables in implemented functions 15\n

Bug: webrtc:370878648
Change-Id: I4529c17f54c653864cca27097e44c843210b9c52
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/368061
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Dor Hen <dorhen@meta.com>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43429}

call/call.cc

@@ -116,7 +116,7 @@ class PayloadTypeSuggesterForTests : public PayloadTypeSuggester {
   }
   RTCError AddLocalMapping(const std::string& /* mid */,
                            PayloadType /* payload_type */,
-                           const cricket::Codec& codec) override {
+                           const cricket::Codec& /* codec */) override {
     return RTCError::OK();
   }
 
@@ -545,9 +545,9 @@ std::unique_ptr<Call> Call::Create(CallConfig config) {
 // Call perf test will use Internal::Call::CreateVideoSendStream() to inject
 // FecController.
 VideoSendStream* Call::CreateVideoSendStream(
-    VideoSendStream::Config config,
+    VideoSendStream::Config /* config */,
-    VideoEncoderConfig encoder_config,
+    VideoEncoderConfig /* encoder_config */,
-    std::unique_ptr<FecController> fec_controller) {
+    std::unique_ptr<FecController> /* fec_controller */) {
   return nullptr;
 }
 

modules/pacing/task_queue_paced_sender_unittest.cc

@@ -241,7 +241,7 @@ TEST(TaskQueuePacedSenderTest, ReschedulesProcessOnRateChange) {
   EXPECT_CALL(packet_router, SendPacket)
       .Times(3)
       .WillRepeatedly([&](std::unique_ptr<RtpPacketToSend> /* packet */,
-                          const PacedPacketInfo& cluster_info) {
+                          const PacedPacketInfo& /* cluster_info */) {
         if (first_packet_time.IsInfinite()) {
           first_packet_time = time_controller.GetClock()->CurrentTime();
         } else if (second_packet_time.IsInfinite()) {

modules/video_coding/media_opt_util.cc

@@ -463,7 +463,7 @@ int VCMFecMethod::BitsPerFrame(const VCMProtectionParameters* parameters) {
 }
 
 bool VCMFecMethod::EffectivePacketLoss(
-    const VCMProtectionParameters* parameters) {
+    const VCMProtectionParameters* /* parameters */) {
   // Effective packet loss to encoder is based on RPL (residual packet loss)
   // this is a soft setting based on degree of FEC protection
   // RPL = received/input packet loss - average_FEC_recovery

modules/video_coding/nack_requester_unittest.cc

@@ -34,7 +34,7 @@ class TestNackRequester : public ::testing::Test,
   void SetUp() override {}
 
   void SendNack(const std::vector<uint16_t>& sequence_numbers,
-                bool buffering_allowed) override {
+                bool /* buffering_allowed */) override {
     sent_nacks_.insert(sent_nacks_.end(), sequence_numbers.begin(),
                        sequence_numbers.end());
     if (waiting_for_send_nack_) {
@@ -276,7 +276,7 @@ class TestNackRequesterWithFieldTrial : public ::testing::Test,
         keyframes_requested_(0) {}
 
   void SendNack(const std::vector<uint16_t>& sequence_numbers,
-                bool buffering_allowed) override {
+                bool /* buffering_allowed */) override {
     sent_nacks_.insert(sent_nacks_.end(), sequence_numbers.begin(),
                        sequence_numbers.end());
   }

modules/video_coding/rtp_frame_reference_finder.cc

@@ -114,9 +114,9 @@ RtpFrameReferenceFinderImpl::PaddingReceived(uint16_t seq_num) {
 
 void RtpFrameReferenceFinderImpl::ClearTo(uint16_t seq_num) {
   struct ClearToVisitor {
-    void operator()(absl::monostate& ref_finder) {}
+    void operator()(absl::monostate& /* ref_finder */) {}
-    void operator()(RtpGenericFrameRefFinder& ref_finder) {}
+    void operator()(RtpGenericFrameRefFinder& /* ref_finder */) {}
-    void operator()(RtpFrameIdOnlyRefFinder& ref_finder) {}
+    void operator()(RtpFrameIdOnlyRefFinder& /* ref_finder */) {}
     void operator()(RtpSeqNumOnlyRefFinder& ref_finder) {
       ref_finder.ClearTo(seq_num);
     }

modules/video_coding/rtp_frame_reference_finder_unittest.cc

@@ -150,7 +150,7 @@ class TestRtpFrameReferenceFinder : public ::testing::Test {
     RefsToSet(m, refs...);
   }
 
-  void RefsToSet(std::set<int64_t>* m) const {}
+  void RefsToSet(std::set<int64_t>* /* m */) const {}
 
   Random rand_;
   std::unique_ptr<RtpFrameReferenceFinder> reference_finder_;

modules/video_coding/utility/simulcast_rate_allocator.cc

@@ -283,7 +283,7 @@ void SimulcastRateAllocator::DistributeAllocationToTemporalLayers(
 
 std::vector<uint32_t> SimulcastRateAllocator::DefaultTemporalLayerAllocation(
     int bitrate_kbps,
-    int max_bitrate_kbps,
+    int /* max_bitrate_kbps */,
     int simulcast_id) const {
   const size_t num_temporal_layers = NumTemporalStreams(simulcast_id);
   std::vector<uint32_t> bitrates;

modules/video_coding/utility/simulcast_test_fixture_impl.cc

@@ -145,13 +145,14 @@ class SimulcastTestFixtureImpl::TestDecodedImageCallback
     decoded_frames_++;
     return 0;
   }
-  int32_t Decoded(VideoFrame& decoded_image, int64_t decode_time_ms) override {
+  int32_t Decoded(VideoFrame& /* decoded_image */,
+                  int64_t /* decode_time_ms */) override {
     RTC_DCHECK_NOTREACHED();
     return -1;
   }
   void Decoded(VideoFrame& decoded_image,
-               std::optional<int32_t> decode_time_ms,
+               std::optional<int32_t> /* decode_time_ms */,
-               std::optional<uint8_t> qp) override {
+               std::optional<uint8_t> /* qp */) override {
     Decoded(decoded_image);
   }
   int DecodedFrames() { return decoded_frames_; }
@@ -921,9 +922,9 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() {
 
   EXPECT_CALL(encoder_callback, OnEncodedImage(_, _))
       .Times(3)
-      .WillRepeatedly(
+      .WillRepeatedly(::testing::Invoke(
-          ::testing::Invoke([&](const EncodedImage& encoded_image,
+          [&](const EncodedImage& encoded_image,
-                                const CodecSpecificInfo* codec_specific_info) {
+              const CodecSpecificInfo* /* codec_specific_info */) {
             EXPECT_EQ(encoded_image._frameType, VideoFrameType::kVideoFrameKey);
 
             size_t index = encoded_image.SimulcastIndex().value_or(0);
@@ -936,30 +937,33 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() {
   EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL));
 
   EXPECT_CALL(decoder_callback, Decoded(_, _, _))
-      .WillOnce(::testing::Invoke([](VideoFrame& decodedImage,
+      .WillOnce(
-                                     std::optional<int32_t> decode_time_ms,
+          ::testing::Invoke([](VideoFrame& decodedImage,
-                                     std::optional<uint8_t> qp) {
+                               std::optional<int32_t> /* decode_time_ms */,
-        EXPECT_EQ(decodedImage.width(), kDefaultWidth / 4);
+                               std::optional<uint8_t> /* qp */) {
-        EXPECT_EQ(decodedImage.height(), kDefaultHeight / 4);
+            EXPECT_EQ(decodedImage.width(), kDefaultWidth / 4);
-      }));
+            EXPECT_EQ(decodedImage.height(), kDefaultHeight / 4);
+          }));
   EXPECT_EQ(0, decoder_->Decode(encoded_frame[0], 0));
 
   EXPECT_CALL(decoder_callback, Decoded(_, _, _))
-      .WillOnce(::testing::Invoke([](VideoFrame& decodedImage,
+      .WillOnce(
-                                     std::optional<int32_t> decode_time_ms,
+          ::testing::Invoke([](VideoFrame& decodedImage,
-                                     std::optional<uint8_t> qp) {
+                               std::optional<int32_t> /* decode_time_ms */,
-        EXPECT_EQ(decodedImage.width(), kDefaultWidth / 2);
+                               std::optional<uint8_t> /* qp */) {
-        EXPECT_EQ(decodedImage.height(), kDefaultHeight / 2);
+            EXPECT_EQ(decodedImage.width(), kDefaultWidth / 2);
-      }));
+            EXPECT_EQ(decodedImage.height(), kDefaultHeight / 2);
+          }));
   EXPECT_EQ(0, decoder_->Decode(encoded_frame[1], 0));
 
   EXPECT_CALL(decoder_callback, Decoded(_, _, _))
-      .WillOnce(::testing::Invoke([](VideoFrame& decodedImage,
+      .WillOnce(
-                                     std::optional<int32_t> decode_time_ms,
+          ::testing::Invoke([](VideoFrame& decodedImage,
-                                     std::optional<uint8_t> qp) {
+                               std::optional<int32_t> /* decode_time_ms */,
-        EXPECT_EQ(decodedImage.width(), kDefaultWidth);
+                               std::optional<uint8_t> /* qp */) {
-        EXPECT_EQ(decodedImage.height(), kDefaultHeight);
+            EXPECT_EQ(decodedImage.width(), kDefaultWidth);
-      }));
+            EXPECT_EQ(decodedImage.height(), kDefaultHeight);
+          }));
   EXPECT_EQ(0, decoder_->Decode(encoded_frame[2], 0));
 }
 

modules/video_coding/video_coding_defines.cc

@@ -12,8 +12,8 @@
 
 namespace webrtc {
 
-void VCMReceiveCallback::OnDroppedFrames(uint32_t frames_dropped) {}
+void VCMReceiveCallback::OnDroppedFrames(uint32_t /* frames_dropped */) {}
-void VCMReceiveCallback::OnIncomingPayloadType(int payload_type) {}
+void VCMReceiveCallback::OnIncomingPayloadType(int /* payload_type */) {}
 void VCMReceiveCallback::OnDecoderInfoChanged(
     const VideoDecoder::DecoderInfo&) {}
 

net/dcsctp/fuzzers/dcsctp_fuzzers.h

@@ -28,7 +28,7 @@ class FuzzerTimeout : public Timeout {
   explicit FuzzerTimeout(std::set<TimeoutID>& active_timeouts)
       : active_timeouts_(active_timeouts) {}
 
-  void Start(DurationMs duration_ms, TimeoutID timeout_id) override {
+  void Start(DurationMs /* duration_ms */, TimeoutID timeout_id) override {
     // Start is only allowed to be called on stopped or expired timeouts.
     if (timeout_id_.has_value()) {
       // It has been started before, but maybe it expired. Ensure that it's not
@@ -60,22 +60,25 @@ class FuzzerCallbacks : public DcSctpSocketCallbacks {
     sent_packets_.emplace_back(std::vector<uint8_t>(data.begin(), data.end()));
   }
   std::unique_ptr<Timeout> CreateTimeout(
-      webrtc::TaskQueueBase::DelayPrecision precision) override {
+      webrtc::TaskQueueBase::DelayPrecision /* precision */) override {
     // The fuzzer timeouts don't implement |precision|.
     return std::make_unique<FuzzerTimeout>(active_timeouts_);
   }
   webrtc::Timestamp Now() override { return webrtc::Timestamp::Millis(42); }
-  uint32_t GetRandomInt(uint32_t low, uint32_t high) override {
+  uint32_t GetRandomInt(uint32_t /* low */, uint32_t /* high */) override {
     return kRandomValue;
   }
-  void OnMessageReceived(DcSctpMessage message) override {}
+  void OnMessageReceived(DcSctpMessage /* message */) override {}
-  void OnError(ErrorKind error, absl::string_view message) override {}
+  void OnError(ErrorKind /* error */,
-  void OnAborted(ErrorKind error, absl::string_view message) override {}
+               absl::string_view /* message */) override {}
+  void OnAborted(ErrorKind /* error */,
+                 absl::string_view /* message */) override {}
   void OnConnected() override {}
   void OnClosed() override {}
   void OnConnectionRestarted() override {}
-  void OnStreamsResetFailed(rtc::ArrayView<const StreamID> outgoing_streams,
+  void OnStreamsResetFailed(
-                            absl::string_view reason) override {}
+      rtc::ArrayView<const StreamID> /* outgoing_streams */,
+      absl::string_view /* reason */) override {}
   void OnStreamsResetPerformed(
       rtc::ArrayView<const StreamID> outgoing_streams) override {}
   void OnIncomingStreamsReset(

net/dcsctp/public/dcsctp_socket.h

@@ -287,7 +287,7 @@ class DcSctpSocketCallbacks {
   //
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
-  virtual void SendPacket(rtc::ArrayView<const uint8_t> data) {}
+  virtual void SendPacket(rtc::ArrayView<const uint8_t> /* data */) {}
 
   // Called when the library wants the packet serialized as `data` to be sent.
   //
@@ -312,7 +312,7 @@ class DcSctpSocketCallbacks {
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
   virtual std::unique_ptr<Timeout> CreateTimeout(
-      webrtc::TaskQueueBase::DelayPrecision precision) {
+      webrtc::TaskQueueBase::DelayPrecision /* precision */) {
     // TODO(hbos): When dependencies have migrated to this new signature, make
     // this pure virtual and delete the other version.
     return CreateTimeout();
@@ -423,7 +423,7 @@ class DcSctpSocketCallbacks {
   // below the threshold set when calling `SetBufferedAmountLowThreshold`.
   //
   // It is allowed to call into this library from within this callback.
-  virtual void OnBufferedAmountLow(StreamID stream_id) {}
+  virtual void OnBufferedAmountLow(StreamID /* stream_id */) {}
 
   // Will be called when the total amount of data buffered (in the entire send
   // buffer, for all streams) falls to or below the threshold specified in
@@ -456,7 +456,7 @@ class DcSctpSocketCallbacks {
   //
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
-  virtual void OnLifecycleMessageFullySent(LifecycleId lifecycle_id) {}
+  virtual void OnLifecycleMessageFullySent(LifecycleId /* lifecycle_id */) {}
 
   // OnLifecycleMessageExpired will be called when a message has expired. If it
   // was expired with data remaining in the send queue that had not been sent
@@ -474,8 +474,8 @@ class DcSctpSocketCallbacks {
   //
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
-  virtual void OnLifecycleMessageExpired(LifecycleId lifecycle_id,
+  virtual void OnLifecycleMessageExpired(LifecycleId /* lifecycle_id */,
-                                         bool maybe_delivered) {}
+                                         bool /* maybe_delivered */) {}
 
   // OnLifecycleMessageDelivered will be called when a non-expired message has
   // been acknowledged by the peer as delivered.
@@ -493,7 +493,7 @@ class DcSctpSocketCallbacks {
   //
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
-  virtual void OnLifecycleMessageDelivered(LifecycleId lifecycle_id) {}
+  virtual void OnLifecycleMessageDelivered(LifecycleId /* lifecycle_id */) {}
 
   // OnLifecycleEnd will be called when a lifecycle event has reached its end.
   // It will be called when processing of a message is complete, no matter how
@@ -513,7 +513,7 @@ class DcSctpSocketCallbacks {
   //
   // Note that it's NOT ALLOWED to call into this library from within this
   // callback.
-  virtual void OnLifecycleEnd(LifecycleId lifecycle_id) {}
+  virtual void OnLifecycleEnd(LifecycleId /* lifecycle_id */) {}
 };
 
 // The DcSctpSocket implementation implements the following interface.

net/dcsctp/rx/interleaved_reassembly_streams.cc

@@ -221,7 +221,7 @@ int InterleavedReassemblyStreams::Add(UnwrappedTSN tsn, Data data) {
 }
 
 size_t InterleavedReassemblyStreams::HandleForwardTsn(
-    UnwrappedTSN new_cumulative_ack_tsn,
+    UnwrappedTSN /* new_cumulative_ack_tsn */,
     rtc::ArrayView<const AnyForwardTsnChunk::SkippedStream> skipped_streams) {
   size_t removed_bytes = 0;
   for (const auto& skipped : skipped_streams) {

net/dcsctp/socket/callback_deferrer.cc

@@ -92,7 +92,7 @@ void CallbackDeferrer::OnAborted(ErrorKind error, absl::string_view message) {
 void CallbackDeferrer::OnConnected() {
   RTC_DCHECK(prepared_);
   deferred_.emplace_back(
-      +[](CallbackData data, DcSctpSocketCallbacks& cb) {
+      +[](CallbackData /* data */, DcSctpSocketCallbacks& cb) {
         return cb.OnConnected();
       },
       absl::monostate{});
@@ -101,7 +101,7 @@ void CallbackDeferrer::OnConnected() {
 void CallbackDeferrer::OnClosed() {
   RTC_DCHECK(prepared_);
   deferred_.emplace_back(
-      +[](CallbackData data, DcSctpSocketCallbacks& cb) {
+      +[](CallbackData /* data */, DcSctpSocketCallbacks& cb) {
         return cb.OnClosed();
       },
       absl::monostate{});
@@ -110,7 +110,7 @@ void CallbackDeferrer::OnClosed() {
 void CallbackDeferrer::OnConnectionRestarted() {
   RTC_DCHECK(prepared_);
   deferred_.emplace_back(
-      +[](CallbackData data, DcSctpSocketCallbacks& cb) {
+      +[](CallbackData /* data */, DcSctpSocketCallbacks& cb) {
         return cb.OnConnectionRestarted();
       },
       absl::monostate{});
@@ -164,7 +164,7 @@ void CallbackDeferrer::OnBufferedAmountLow(StreamID stream_id) {
 void CallbackDeferrer::OnTotalBufferedAmountLow() {
   RTC_DCHECK(prepared_);
   deferred_.emplace_back(
-      +[](CallbackData data, DcSctpSocketCallbacks& cb) {
+      +[](CallbackData /* data */, DcSctpSocketCallbacks& cb) {
         return cb.OnTotalBufferedAmountLow();
       },
       absl::monostate{});

net/dcsctp/socket/dcsctp_socket.cc

@@ -1042,7 +1042,7 @@ void DcSctpSocket::ReportFailedToParseChunk(int chunk_type) {
   callbacks_.OnError(ErrorKind::kParseFailed, sb.str());
 }
 
-void DcSctpSocket::HandleData(const CommonHeader& header,
+void DcSctpSocket::HandleData(const CommonHeader& /* header */,
                               const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<DataChunk> chunk = DataChunk::Parse(descriptor.data);
   if (ValidateParseSuccess(chunk) && ValidateHasTCB()) {
@@ -1050,7 +1050,7 @@ void DcSctpSocket::HandleData(const CommonHeader& header,
   }
 }
 
-void DcSctpSocket::HandleIData(const CommonHeader& header,
+void DcSctpSocket::HandleIData(const CommonHeader& /* header */,
                                const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<IDataChunk> chunk = IDataChunk::Parse(descriptor.data);
   if (ValidateParseSuccess(chunk) && ValidateHasTCB()) {
@@ -1117,7 +1117,7 @@ void DcSctpSocket::HandleDataCommon(AnyDataChunk& chunk) {
   }
 }
 
-void DcSctpSocket::HandleInit(const CommonHeader& header,
+void DcSctpSocket::HandleInit(const CommonHeader& /* header */,
                               const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<InitChunk> chunk = InitChunk::Parse(descriptor.data);
   if (!ValidateParseSuccess(chunk)) {
@@ -1247,7 +1247,7 @@ void DcSctpSocket::HandleInit(const CommonHeader& header,
 }
 
 void DcSctpSocket::HandleInitAck(
-    const CommonHeader& header,
+    const CommonHeader& /* header */,
     const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<InitAckChunk> chunk = InitAckChunk::Parse(descriptor.data);
   if (!ValidateParseSuccess(chunk)) {
@@ -1446,7 +1446,7 @@ bool DcSctpSocket::HandleCookieEchoWithTCB(const CommonHeader& header,
 }
 
 void DcSctpSocket::HandleCookieAck(
-    const CommonHeader& header,
+    const CommonHeader& /* header */,
     const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<CookieAckChunk> chunk = CookieAckChunk::Parse(descriptor.data);
   if (!ValidateParseSuccess(chunk)) {
@@ -1477,7 +1477,7 @@ void DcSctpSocket::MaybeDeliverMessages() {
   }
 }
 
-void DcSctpSocket::HandleSack(const CommonHeader& header,
+void DcSctpSocket::HandleSack(const CommonHeader& /* header */,
                               const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<SackChunk> chunk = SackChunk::Parse(descriptor.data);
 
@@ -1510,7 +1510,7 @@ void DcSctpSocket::HandleSack(const CommonHeader& header,
 }
 
 void DcSctpSocket::HandleHeartbeatRequest(
-    const CommonHeader& header,
+    const CommonHeader& /* header */,
     const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<HeartbeatRequestChunk> chunk =
       HeartbeatRequestChunk::Parse(descriptor.data);
@@ -1521,7 +1521,7 @@ void DcSctpSocket::HandleHeartbeatRequest(
 }
 
 void DcSctpSocket::HandleHeartbeatAck(
-    const CommonHeader& header,
+    const CommonHeader& /* header */,
     const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<HeartbeatAckChunk> chunk =
       HeartbeatAckChunk::Parse(descriptor.data);
@@ -1531,7 +1531,7 @@ void DcSctpSocket::HandleHeartbeatAck(
   }
 }
 
-void DcSctpSocket::HandleAbort(const CommonHeader& header,
+void DcSctpSocket::HandleAbort(const CommonHeader& /* header */,
                                const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<AbortChunk> chunk = AbortChunk::Parse(descriptor.data);
   if (ValidateParseSuccess(chunk)) {
@@ -1551,7 +1551,7 @@ void DcSctpSocket::HandleAbort(const CommonHeader& header,
   }
 }
 
-void DcSctpSocket::HandleError(const CommonHeader& header,
+void DcSctpSocket::HandleError(const CommonHeader& /* header */,
                                const SctpPacket::ChunkDescriptor& descriptor) {
   std::optional<ErrorChunk> chunk = ErrorChunk::Parse(descriptor.data);
   if (ValidateParseSuccess(chunk)) {
@@ -1569,7 +1569,7 @@ void DcSctpSocket::HandleError(const CommonHeader& header,
 }
 
 void DcSctpSocket::HandleReconfig(
-    const CommonHeader& header,
+    const CommonHeader& /* header */,
     const SctpPacket::ChunkDescriptor& descriptor) {
   Timestamp now = callbacks_.Now();
   std::optional<ReConfigChunk> chunk = ReConfigChunk::Parse(descriptor.data);

net/dcsctp/socket/dcsctp_socket_network_test.cc

@@ -216,18 +216,19 @@ class SctpActor : public DcSctpSocketCallbacks {
 
   void OnConnectionRestarted() override {}
 
-  void OnStreamsResetFailed(rtc::ArrayView<const StreamID> outgoing_streams,
+  void OnStreamsResetFailed(
-                            absl::string_view reason) override {}
+      rtc::ArrayView<const StreamID> /* outgoing_streams */,
+      absl::string_view /* reason */) override {}
 
   void OnStreamsResetPerformed(
-      rtc::ArrayView<const StreamID> outgoing_streams) override {}
+      rtc::ArrayView<const StreamID> /* outgoing_streams */) override {}
 
   void OnIncomingStreamsReset(
-      rtc::ArrayView<const StreamID> incoming_streams) override {}
+      rtc::ArrayView<const StreamID> /* incoming_streams */) override {}
 
   void NotifyOutgoingMessageBufferEmpty() override {}
 
-  void OnBufferedAmountLow(StreamID stream_id) override {
+  void OnBufferedAmountLow(StreamID /* stream_id */) override {
     if (mode_ == ActorMode::kThroughputSender) {
       std::vector<uint8_t> payload(kHugePayloadSize);
       sctp_socket_.Send(DcSctpMessage(kStreamId, kPpid, std::move(payload)),

net/dcsctp/socket/mock_dcsctp_socket_callbacks.h

@@ -89,7 +89,7 @@ class MockDcSctpSocketCallbacks : public DcSctpSocketCallbacks {
               (override));
 
   std::unique_ptr<Timeout> CreateTimeout(
-      webrtc::TaskQueueBase::DelayPrecision precision) override {
+      webrtc::TaskQueueBase::DelayPrecision /* precision */) override {
     // The fake timeout manager does not implement |precision|.
     return timeout_manager_.CreateTimeout();
   }

net/dcsctp/socket/stream_reset_handler_test.cc

@@ -114,7 +114,7 @@ class StreamResetHandlerTest : public testing::Test {
             kMyInitialTsn,
             kArwnd,
             producer_,
-            [](TimeDelta rtt) {},
+            [](TimeDelta /* rtt */) {},
             []() {},
             *t3_rtx_timer_,
             DcSctpOptions())),
@@ -202,8 +202,8 @@ class StreamResetHandlerTest : public testing::Test {
     reasm_ = std::make_unique<ReassemblyQueue>("log: ", kArwnd);
     reasm_->RestoreFromState(state);
     retransmission_queue_ = std::make_unique<RetransmissionQueue>(
-        "", &callbacks_, kMyInitialTsn, kArwnd, producer_, [](TimeDelta rtt) {},
+        "", &callbacks_, kMyInitialTsn, kArwnd, producer_,
-        []() {}, *t3_rtx_timer_, DcSctpOptions(),
+        [](TimeDelta /* rtt */) {}, []() {}, *t3_rtx_timer_, DcSctpOptions(),
         /*supports_partial_reliability=*/true,
         /*use_message_interleaving=*/false);
     retransmission_queue_->RestoreFromState(state);

net/dcsctp/timer/fake_timeout.h

@@ -79,7 +79,7 @@ class FakeTimeoutManager {
     return timer;
   }
   std::unique_ptr<FakeTimeout> CreateTimeout(
-      webrtc::TaskQueueBase::DelayPrecision precision) {
+      webrtc::TaskQueueBase::DelayPrecision /* precision */) {
     // FakeTimeout does not support implement |precision|.
     return CreateTimeout();
   }

net/dcsctp/timer/task_queue_timeout_test.cc

@@ -129,7 +129,7 @@ TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToLow) {
           _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
-      [](TimeoutID timeout_id) {});
+      [](TimeoutID /* timeout_id */) {});
   std::unique_ptr<Timeout> timeout =
       factory.CreateTimeout(webrtc::TaskQueueBase::DelayPrecision::kLow);
   timeout->Start(DurationMs(1), TimeoutID(1));
@@ -147,7 +147,7 @@ TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToHigh) {
           _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
-      [](TimeoutID timeout_id) {});
+      [](TimeoutID /* timeout_id */) {});
   std::unique_ptr<Timeout> timeout =
       factory.CreateTimeout(webrtc::TaskQueueBase::DelayPrecision::kHigh);
   timeout->Start(DurationMs(1), TimeoutID(1));
@@ -165,7 +165,7 @@ TEST(TaskQueueTimeoutWithMockTaskQueueTest, TimeoutPrecisionIsLowByDefault) {
           _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
-      [](TimeoutID timeout_id) {});
+      [](TimeoutID /* timeout_id */) {});
   std::unique_ptr<Timeout> timeout = factory.CreateTimeout();
   timeout->Start(DurationMs(1), TimeoutID(1));
 }

net/dcsctp/tx/mock_send_queue.h

@@ -25,7 +25,7 @@ class MockSendQueue : public SendQueue {
  public:
   MockSendQueue() {
     ON_CALL(*this, Produce)
-        .WillByDefault([](webrtc::Timestamp now, size_t max_size) {
+        .WillByDefault([](webrtc::Timestamp /* now */, size_t /* max_size */) {
           return std::nullopt;
         });
   }

net/dcsctp/tx/retransmission_queue.cc

@@ -164,7 +164,8 @@ void RetransmissionQueue::HandleIncreasedCumulativeTsnAck(
   }
 }
 
-void RetransmissionQueue::HandlePacketLoss(UnwrappedTSN highest_tsn_acked) {
+void RetransmissionQueue::HandlePacketLoss(
+    UnwrappedTSN /* highest_tsn_acked */) {
   if (!is_in_fast_recovery()) {
     // https://tools.ietf.org/html/rfc4960#section-7.2.4
     // "If not in Fast Recovery, adjust the ssthresh and cwnd of the

net/dcsctp/tx/retransmission_queue_test.cc

@@ -81,7 +81,7 @@ class RetransmissionQueueTest : public testing::Test {
 
   std::function<SendQueue::DataToSend(Timestamp, size_t)> CreateChunk(
       OutgoingMessageId message_id) {
-    return [this, message_id](Timestamp now, size_t max_size) {
+    return [this, message_id](Timestamp /* now */, size_t /* max_size */) {
       return SendQueue::DataToSend(message_id,
                                    gen_.Ordered({1, 2, 3, 4}, "BE"));
     };

net/dcsctp/tx/stream_scheduler_test.cc

@@ -45,7 +45,8 @@ CreateChunk(OutgoingMessageId message_id,
             StreamID sid,
             MID mid,
             size_t payload_size = kPayloadSize) {
-  return [sid, mid, payload_size, message_id](Timestamp now, size_t max_size) {
+  return [sid, mid, payload_size, message_id](Timestamp /* now */,
+                                              size_t /* max_size */) {
     return SendQueue::DataToSend(
         message_id,
         Data(sid, SSN(0), mid, FSN(0), PPID(42),

p2p/base/async_stun_tcp_socket.cc

@@ -132,7 +132,7 @@ size_t AsyncStunTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
 }
 
 size_t AsyncStunTCPSocket::GetExpectedLength(const void* data,
-                                             size_t len,
+                                             size_t /* len */,
                                              int* pad_bytes) {
   *pad_bytes = 0;
   PacketLength pkt_len =

p2p/base/async_stun_tcp_socket_unittest.cc

@@ -100,15 +100,15 @@ class AsyncStunTCPSocketTest : public ::testing::Test,
     vss_->ProcessMessagesUntilIdle();
   }
 
-  void OnReadPacket(rtc::AsyncPacketSocket* socket,
+  void OnReadPacket(rtc::AsyncPacketSocket* /* socket */,
                     const rtc::ReceivedPacket& packet) {
     recv_packets_.push_back(
         std::string(reinterpret_cast<const char*>(packet.payload().data()),
                     packet.payload().size()));
   }
 
-  void OnSentPacket(rtc::AsyncPacketSocket* socket,
+  void OnSentPacket(rtc::AsyncPacketSocket* /* socket */,
-                    const rtc::SentPacket& packet) {
+                    const rtc::SentPacket& /* packet */) {
     ++sent_packets_;
   }
 
@@ -172,7 +172,8 @@ TEST_F(AsyncStunTCPSocketTest, TestMultipleStunPackets) {
 
 TEST_F(AsyncStunTCPSocketTest, ProcessInputHandlesMultiplePackets) {
   send_socket_->RegisterReceivedPacketCallback(
-      [&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+      [&](rtc::AsyncPacketSocket* /* socket */,
+          const rtc::ReceivedPacket& packet) {
         recv_packets_.push_back(
             std::string(reinterpret_cast<const char*>(packet.payload().data()),
                         packet.payload().size()));

p2p/base/basic_ice_controller.cc

@@ -415,7 +415,7 @@ BasicIceController::GetBestWritableConnectionPerNetwork() const {
 
 IceControllerInterface::SwitchResult
 BasicIceController::HandleInitialSelectDampening(
-    IceSwitchReason reason,
+    IceSwitchReason /* reason */,
     const Connection* new_connection) {
   if (!field_trials_->initial_select_dampening.has_value() &&
       !field_trials_->initial_select_dampening_ping_received.has_value()) {
@@ -732,7 +732,7 @@ int BasicIceController::CompareConnections(
 int BasicIceController::CompareCandidatePairNetworks(
     const Connection* a,
     const Connection* b,
-    std::optional<rtc::AdapterType> network_preference) const {
+    std::optional<rtc::AdapterType> /* network_preference */) const {
   int compare_a_b_by_network_preference =
       CompareCandidatePairsByNetworkPreference(a, b,
                                                config_.network_preference);

p2p/base/connection.cc

@@ -1155,7 +1155,7 @@ int64_t Connection::last_data_received() const {
 
 void Connection::ReceivedPingResponse(
     int rtt,
-    absl::string_view request_id,
+    absl::string_view /* request_id */,
     const std::optional<uint32_t>& nomination) {
   RTC_DCHECK_RUN_ON(network_thread_);
   RTC_DCHECK_GE(rtt, 0);

p2p/base/dtls_transport.cc

@@ -78,7 +78,7 @@ StreamInterfaceChannel::StreamInterfaceChannel(
 
 rtc::StreamResult StreamInterfaceChannel::Read(rtc::ArrayView<uint8_t> buffer,
                                                size_t& read,
-                                               int& error) {
+                                               int& /* error */) {
   RTC_DCHECK_RUN_ON(&callback_sequence_);
 
   if (state_ == rtc::SS_CLOSED)
@@ -96,7 +96,7 @@ rtc::StreamResult StreamInterfaceChannel::Read(rtc::ArrayView<uint8_t> buffer,
 rtc::StreamResult StreamInterfaceChannel::Write(
     rtc::ArrayView<const uint8_t> data,
     size_t& written,
-    int& error) {
+    int& /* error */) {
   RTC_DCHECK_RUN_ON(&callback_sequence_);
   // Always succeeds, since this is an unreliable transport anyway.
   // TODO(zhihuang): Should this block if ice_transport_'s temporarily
@@ -685,13 +685,14 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
   }
 }
 
-void DtlsTransport::OnSentPacket(rtc::PacketTransportInternal* transport,
+void DtlsTransport::OnSentPacket(rtc::PacketTransportInternal* /* transport */,
                                  const rtc::SentPacket& sent_packet) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   SignalSentPacket(this, sent_packet);
 }
 
-void DtlsTransport::OnReadyToSend(rtc::PacketTransportInternal* transport) {
+void DtlsTransport::OnReadyToSend(
+    rtc::PacketTransportInternal* /* transport */) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   if (writable()) {
     SignalReadyToSend(this);

p2p/base/dtls_transport_internal.h

@@ -106,7 +106,7 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal {
       std::optional<rtc::SSLRole> role) = 0;
 
   ABSL_DEPRECATED("Set the max version via construction.")
-  bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version) {
+  bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion /* version */) {
     return true;
   }
 

p2p/base/dtls_transport_unittest.cc

@@ -250,7 +250,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
                      << "' is writable";
   }
 
-  void OnTransportReadPacket(rtc::PacketTransportInternal* transport,
+  void OnTransportReadPacket(rtc::PacketTransportInternal* /* transport */,
                              const rtc::ReceivedPacket& packet) {
     uint32_t packet_num = 0;
     ASSERT_TRUE(VerifyPacket(packet.payload(), &packet_num));
@@ -268,7 +268,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
     }
   }
 
-  void OnTransportSentPacket(rtc::PacketTransportInternal* transport,
+  void OnTransportSentPacket(rtc::PacketTransportInternal* /* transport */,
                              const rtc::SentPacket& sent_packet) {
     sent_packet_ = sent_packet;
   }
@@ -276,8 +276,9 @@ class DtlsTestClient : public sigslot::has_slots<> {
   rtc::SentPacket sent_packet() const { return sent_packet_; }
 
   // Hook into the raw packet stream to make sure DTLS packets are encrypted.
-  void OnFakeIceTransportReadPacket(rtc::PacketTransportInternal* transport,
+  void OnFakeIceTransportReadPacket(
-                                    const rtc::ReceivedPacket& packet) {
+      rtc::PacketTransportInternal* /* transport */,
+      const rtc::ReceivedPacket& packet) {
     // Packets should not be decrypted on the underlying Transport packets.
     ASSERT_EQ(packet.decryption_info(), rtc::ReceivedPacket::kNotDecrypted);
 

p2p/base/fake_dtls_transport.h

@@ -271,7 +271,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
   }
 
  private:
-  void OnIceTransportReadPacket(PacketTransportInternal* ice_,
+  void OnIceTransportReadPacket(PacketTransportInternal* /* ice_ */,
                                 const rtc::ReceivedPacket& packet) {
     NotifyPacketReceived(packet);
   }

p2p/base/fake_ice_transport.h

@@ -312,7 +312,7 @@ class FakeIceTransport : public IceTransportInternal {
   int SendPacket(const char* data,
                  size_t len,
                  const rtc::PacketOptions& options,
-                 int flags) override {
+                 int /* flags */) override {
     RTC_DCHECK_RUN_ON(network_thread_);
     if (!dest_) {
       return -1;

p2p/base/fake_packet_transport.h

@@ -60,7 +60,7 @@ class FakePacketTransport : public PacketTransportInternal {
   int SendPacket(const char* data,
                  size_t len,
                  const PacketOptions& options,
-                 int flags) override {
+                 int /* flags */) override {
     if (!dest_ || error_ != 0) {
       return -1;
     }

p2p/base/fake_port_allocator.h

@@ -203,7 +203,7 @@ class FakePortAllocatorSession : public PortAllocatorSession {
     allocation_done_ = true;
     SignalCandidatesAllocationDone(this);
   }
-  void OnPortDestroyed(cricket::PortInterface* port) {
+  void OnPortDestroyed(cricket::PortInterface* /* port */) {
     // Don't want to double-delete port if it deletes itself.
     port_.release();
   }
@@ -242,7 +242,7 @@ class FakePortAllocator : public cricket::PortAllocator {
                           std::move(factory),
                           field_trials) {}
 
-  void SetNetworkIgnoreMask(int network_ignore_mask) override {}
+  void SetNetworkIgnoreMask(int /* network_ignore_mask */) override {}
 
   cricket::PortAllocatorSession* CreateSessionInternal(
       absl::string_view content_name,

p2p/base/ice_transport_internal.h

@@ -257,7 +257,9 @@ class RTC_EXPORT IceTransportInternal : public rtc::PacketTransportInternal {
   // Default implementation in order to allow downstream usage deletion.
   // TODO: bugs.webrtc.org/42224914 - Remove when all downstream overrides are
   // gone.
-  virtual void SetIceTiebreaker(uint64_t tiebreaker) { RTC_CHECK_NOTREACHED(); }
+  virtual void SetIceTiebreaker(uint64_t /* tiebreaker */) {
+    RTC_CHECK_NOTREACHED();
+  }
 
   virtual void SetIceCredentials(absl::string_view ice_ufrag,
                                  absl::string_view ice_pwd);

p2p/base/mock_active_ice_controller.h

@@ -22,7 +22,7 @@ namespace cricket {
 class MockActiveIceController : public cricket::ActiveIceControllerInterface {
  public:
   explicit MockActiveIceController(
-      const cricket::ActiveIceControllerFactoryArgs& args) {}
+      const cricket::ActiveIceControllerFactoryArgs& /* args */) {}
   ~MockActiveIceController() override = default;
 
   MOCK_METHOD(void, SetIceConfig, (const cricket::IceConfig&), (override));

p2p/base/mock_ice_controller.h

@@ -22,7 +22,8 @@ namespace cricket {
 
 class MockIceController : public cricket::IceControllerInterface {
  public:
-  explicit MockIceController(const cricket::IceControllerFactoryArgs& args) {}
+  explicit MockIceController(
+      const cricket::IceControllerFactoryArgs& /* args */) {}
   ~MockIceController() override = default;
 
   MOCK_METHOD(void, SetIceConfig, (const cricket::IceConfig&), (override));

p2p/base/mock_ice_transport.h

@@ -56,21 +56,21 @@ class MockIceTransport : public IceTransportInternal {
 
   const std::string& transport_name() const override { return transport_name_; }
   int component() const override { return 0; }
-  void SetIceRole(IceRole role) override {}
+  void SetIceRole(IceRole /* role */) override {}
   // The ufrag and pwd in `ice_params` must be set
   // before candidate gathering can start.
-  void SetIceParameters(const IceParameters& ice_params) override {}
+  void SetIceParameters(const IceParameters& /* ice_params */) override {}
-  void SetRemoteIceParameters(const IceParameters& ice_params) override {}
+  void SetRemoteIceParameters(const IceParameters& /* ice_params */) override {}
-  void SetRemoteIceMode(IceMode mode) override {}
+  void SetRemoteIceMode(IceMode /* mode */) override {}
-  void SetIceConfig(const IceConfig& config) override {}
+  void SetIceConfig(const IceConfig& /* config */) override {}
   std::optional<int> GetRttEstimate() override { return std::nullopt; }
   const Connection* selected_connection() const override { return nullptr; }
   std::optional<const CandidatePair> GetSelectedCandidatePair() const override {
     return std::nullopt;
   }
   void MaybeStartGathering() override {}
-  void AddRemoteCandidate(const Candidate& candidate) override {}
+  void AddRemoteCandidate(const Candidate& /* candidate */) override {}
-  void RemoveRemoteCandidate(const Candidate& candidate) override {}
+  void RemoveRemoteCandidate(const Candidate& /* candidate */) override {}
   void RemoveAllRemoteCandidates() override {}
   IceGatheringState gathering_state() const override {
     return IceGatheringState::kIceGatheringComplete;

p2p/base/p2p_transport_channel.cc

@@ -900,7 +900,7 @@ void P2PTransportChannel::MaybeStartGathering() {
 }
 
 // A new port is available, attempt to make connections for it
-void P2PTransportChannel::OnPortReady(PortAllocatorSession* session,
+void P2PTransportChannel::OnPortReady(PortAllocatorSession* /* session */,
                                       PortInterface* port) {
   RTC_DCHECK_RUN_ON(network_thread_);
 
@@ -946,7 +946,7 @@ void P2PTransportChannel::OnPortReady(PortAllocatorSession* session,
 
 // A new candidate is available, let listeners know
 void P2PTransportChannel::OnCandidatesReady(
-    PortAllocatorSession* session,
+    PortAllocatorSession* /* session */,
     const std::vector<Candidate>& candidates) {
   RTC_DCHECK_RUN_ON(network_thread_);
   for (size_t i = 0; i < candidates.size(); ++i) {
@@ -955,7 +955,7 @@ void P2PTransportChannel::OnCandidatesReady(
 }
 
 void P2PTransportChannel::OnCandidateError(
-    PortAllocatorSession* session,
+    PortAllocatorSession* /* session */,
     const IceCandidateErrorEvent& event) {
   RTC_DCHECK(network_thread_ == rtc::Thread::Current());
   if (candidate_error_callback_) {
@@ -964,7 +964,7 @@ void P2PTransportChannel::OnCandidateError(
 }
 
 void P2PTransportChannel::OnCandidatesAllocationDone(
-    PortAllocatorSession* session) {
+    PortAllocatorSession* /* session */) {
   RTC_DCHECK_RUN_ON(network_thread_);
   if (config_.gather_continually()) {
     RTC_LOG(LS_INFO) << "P2PTransportChannel: " << transport_name()
@@ -1136,7 +1136,7 @@ void P2PTransportChannel::OnCandidateFilterChanged(uint32_t prev_filter,
   }
 }
 
-void P2PTransportChannel::OnRoleConflict(PortInterface* port) {
+void P2PTransportChannel::OnRoleConflict(PortInterface* /* port */) {
   SignalRoleConflict(this);  // STUN ping will be sent when SetRole is called
                              // from Transport.
 }
@@ -2138,7 +2138,7 @@ void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
 }
 
 void P2PTransportChannel::OnPortsPruned(
-    PortAllocatorSession* session,
+    PortAllocatorSession* /* session */,
     const std::vector<PortInterface*>& ports) {
   RTC_DCHECK_RUN_ON(network_thread_);
   for (PortInterface* port : ports) {

p2p/base/p2p_transport_channel_unittest.cc

@@ -194,7 +194,7 @@ class ResolverFactoryFixture : public webrtc::MockAsyncDnsResolverFactory {
     mock_async_dns_resolver_ = std::make_unique<webrtc::MockAsyncDnsResolver>();
     EXPECT_CALL(*mock_async_dns_resolver_, Start(_, _))
         .WillRepeatedly(
-            [](const rtc::SocketAddress& addr,
+            [](const rtc::SocketAddress& /* addr */,
                absl::AnyInvocable<void()> callback) { callback(); });
     EXPECT_CALL(*mock_async_dns_resolver_, result())
         .WillOnce(ReturnRef(mock_async_dns_resolver_result_));

p2p/base/packet_transport_internal.cc

@@ -19,7 +19,8 @@ PacketTransportInternal::PacketTransportInternal() = default;
 
 PacketTransportInternal::~PacketTransportInternal() = default;
 
-bool PacketTransportInternal::GetOption(rtc::Socket::Option opt, int* value) {
+bool PacketTransportInternal::GetOption(rtc::Socket::Option /* opt */,
+                                        int* /* value */) {
   return false;
 }
 

p2p/base/port.cc

@@ -683,8 +683,8 @@ std::string Port::CreateStunUsername(absl::string_view remote_username) const {
   return std::string(remote_username) + ":" + username_fragment();
 }
 
-bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* /* socket */,
-                                const rtc::ReceivedPacket& packet) {
+                                const rtc::ReceivedPacket& /* packet */) {
   RTC_DCHECK_NOTREACHED();
   return false;
 }

p2p/base/port.h

@@ -363,7 +363,7 @@ class RTC_EXPORT Port : public PortInterface, public sigslot::has_slots<> {
 
   int16_t network_cost() const override { return network_cost_; }
 
-  void GetStunStats(std::optional<StunStats>* stats) override {}
+  void GetStunStats(std::optional<StunStats>* /* stats */) override {}
 
  protected:
   void UpdateNetworkCost() override;
@@ -427,7 +427,7 @@ class RTC_EXPORT Port : public PortInterface, public sigslot::has_slots<> {
   rtc::DiffServCodePoint StunDscpValue() const override;
 
   // Extra work to be done in subclasses when a connection is destroyed.
-  virtual void HandleConnectionDestroyed(Connection* conn) {}
+  virtual void HandleConnectionDestroyed(Connection* /* conn */) {}
 
   void DestroyAllConnections();
 

p2p/base/port_allocator.h

@@ -248,13 +248,13 @@ class RTC_EXPORT PortAllocatorSession : public sigslot::has_slots<> {
   // Get candidate-level stats from all candidates on the ready ports and return
   // the stats to the given list.
   virtual void GetCandidateStatsFromReadyPorts(
-      CandidateStatsList* candidate_stats_list) const {}
+      CandidateStatsList* /* candidate_stats_list */) const {}
   // Set the interval at which STUN candidates will resend STUN binding requests
   // on the underlying ports to keep NAT bindings open.
   // The default value of the interval in implementation is restored if a null
   // optional value is passed.
   virtual void SetStunKeepaliveIntervalForReadyPorts(
-      const std::optional<int>& stun_keepalive_interval) {}
+      const std::optional<int>& /* stun_keepalive_interval */) {}
   // Another way of getting the information provided by the signals below.
   //
   // Ports and candidates are not guaranteed to be in the same order as the
@@ -413,7 +413,8 @@ class RTC_EXPORT PortAllocator : public sigslot::has_slots<> {
 
   // Set list of <ipaddress, mask> that shall be categorized as VPN.
   // Implemented by BasicPortAllocator.
-  virtual void SetVpnList(const std::vector<rtc::NetworkMask>& vpn_list) {}
+  virtual void SetVpnList(const std::vector<rtc::NetworkMask>& /* vpn_list */) {
+  }
 
   std::unique_ptr<PortAllocatorSession> CreateSession(
       absl::string_view content_name,

p2p/base/port_unittest.cc

@@ -173,7 +173,7 @@ class TestPort : public Port {
                ICE_TYPE_PREFERENCE_HOST, 0, "", true);
   }
 
-  virtual bool SupportsProtocol(absl::string_view protocol) const {
+  virtual bool SupportsProtocol(absl::string_view /* protocol */) const {
     return true;
   }
 
@@ -194,7 +194,7 @@ class TestPort : public Port {
   }
 
   virtual Connection* CreateConnection(const Candidate& remote_candidate,
-                                       CandidateOrigin origin) {
+                                       CandidateOrigin /* origin */) {
     Connection* conn = new ProxyConnection(NewWeakPtr(), 0, remote_candidate);
     AddOrReplaceConnection(conn);
     // Set use-candidate attribute flag as this will add USE-CANDIDATE attribute
@@ -204,8 +204,8 @@ class TestPort : public Port {
   }
   virtual int SendTo(const void* data,
                      size_t size,
-                     const rtc::SocketAddress& addr,
+                     const rtc::SocketAddress& /* addr */,
-                     const rtc::PacketOptions& options,
+                     const rtc::PacketOptions& /* options */,
                      bool payload) {
     if (!payload) {
       auto msg = std::make_unique<IceMessage>();
@@ -220,7 +220,9 @@ class TestPort : public Port {
     }
     return static_cast<int>(size);
   }
-  virtual int SetOption(rtc::Socket::Option opt, int value) { return 0; }
+  virtual int SetOption(rtc::Socket::Option /* opt */, int /* value */) {
+    return 0;
+  }
   virtual int GetOption(rtc::Socket::Option opt, int* value) { return -1; }
   virtual int GetError() { return 0; }
   void Reset() {

p2p/base/pseudo_tcp_unittest.cc

@@ -518,9 +518,9 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
 
  private:
   // IPseudoTcpNotify interface
-  virtual void OnTcpReadable(PseudoTcp* tcp) {}
+  virtual void OnTcpReadable(PseudoTcp* /* tcp */) {}
 
-  virtual void OnTcpWriteable(PseudoTcp* tcp) {}
+  virtual void OnTcpWriteable(PseudoTcp* /* tcp */) {}
 
   void ReadUntilIOPending() {
     char block[kBlockSize];

p2p/base/regathering_controller_unittest.cc

@@ -95,7 +95,7 @@ class RegatheringControllerTest : public ::testing::Test,
     allocator_session_->ClearGettingPorts();
   }
 
-  void OnIceRegathering(cricket::PortAllocatorSession* allocator_session,
+  void OnIceRegathering(cricket::PortAllocatorSession* /* allocator_session */,
                         cricket::IceRegatheringReason reason) {
     ++count_[reason];
   }

p2p/base/stun_port.cc

@@ -129,7 +129,7 @@ UDPPort::AddressResolver::AddressResolver(
 void UDPPort::AddressResolver::Resolve(
     const rtc::SocketAddress& address,
     int family,
-    const webrtc::FieldTrialsView& field_trials) {
+    const webrtc::FieldTrialsView& /* field_trials */) {
   if (resolvers_.find(address) != resolvers_.end())
     return;
 
@@ -240,7 +240,7 @@ void UDPPort::MaybePrepareStunCandidate() {
 }
 
 Connection* UDPPort::CreateConnection(const Candidate& address,
-                                      CandidateOrigin origin) {
+                                      CandidateOrigin /* origin */) {
   if (!SupportsProtocol(address.protocol())) {
     return nullptr;
   }
@@ -281,7 +281,7 @@ int UDPPort::SendTo(const void* data,
                     size_t size,
                     const rtc::SocketAddress& addr,
                     const rtc::PacketOptions& options,
-                    bool payload) {
+                    bool /* payload */) {
   rtc::PacketOptions modified_options(options);
   CopyPortInformationToPacketInfo(&modified_options.info_signaled_after_sent);
   int sent = socket_->SendTo(data, size, addr, modified_options);
@@ -350,7 +350,7 @@ void UDPPort::set_stun_keepalive_delay(const std::optional<int>& delay) {
   stun_keepalive_delay_ = delay.value_or(STUN_KEEPALIVE_INTERVAL);
 }
 
-void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
+void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* /* socket */,
                                   const rtc::SocketAddress& address) {
   // When adapter enumeration is disabled and binding to the any address, the
   // default local address will be issued as a candidate instead if
@@ -368,7 +368,7 @@ void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
   MaybePrepareStunCandidate();
 }
 
-void UDPPort::PostAddAddress(bool is_final) {
+void UDPPort::PostAddAddress(bool /* is_final */) {
   MaybeSetPortCompleteOrError();
 }
 
@@ -396,12 +396,12 @@ void UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
   }
 }
 
-void UDPPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
+void UDPPort::OnSentPacket(rtc::AsyncPacketSocket* /* socket */,
                            const rtc::SentPacket& sent_packet) {
   PortInterface::SignalSentPacket(sent_packet);
 }
 
-void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
+void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* /* socket */) {
   Port::OnReadyToSend();
 }
 

p2p/base/stun_port_unittest.cc

@@ -216,16 +216,16 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
     rtc::InitRandom(NULL, 0);
   }
 
-  void OnPortComplete(cricket::Port* port) {
+  void OnPortComplete(cricket::Port* /* port */) {
     ASSERT_FALSE(done_);
     done_ = true;
     error_ = false;
   }
-  void OnPortError(cricket::Port* port) {
+  void OnPortError(cricket::Port* /* port */) {
     done_ = true;
     error_ = true;
   }
-  void OnCandidateError(cricket::Port* port,
+  void OnCandidateError(cricket::Port* /* port */,
                         const cricket::IceCandidateErrorEvent& event) {
     error_event_ = event;
   }
@@ -344,7 +344,7 @@ TEST_F(StunPortWithMockDnsResolverTest, TestPrepareAddressHostname) {
       [](webrtc::MockAsyncDnsResolver* resolver,
          webrtc::MockAsyncDnsResolverResult* resolver_result) {
         EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
-            .WillOnce([](const rtc::SocketAddress& addr, int family,
+            .WillOnce([](const rtc::SocketAddress& /* addr */, int /* family */,
                          absl::AnyInvocable<void()> callback) { callback(); });
 
         EXPECT_CALL(*resolver, result)
@@ -370,7 +370,7 @@ TEST_F(StunPortWithMockDnsResolverTest,
       [](webrtc::MockAsyncDnsResolver* resolver,
          webrtc::MockAsyncDnsResolverResult* resolver_result) {
         EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
-            .WillOnce([](const rtc::SocketAddress& addr, int family,
+            .WillOnce([](const rtc::SocketAddress& /* addr */, int /* family */,
                          absl::AnyInvocable<void()> callback) { callback(); });
         EXPECT_CALL(*resolver, result)
             .WillRepeatedly(ReturnPointee(resolver_result));