admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Comment unused variables in implemented functions 15\n

Browse Source 
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}
This commit is contained in:
Dor Hen 2024-11-20 12:15:38 +02:00 committed by WebRTC LUCI CQ
parent 4c5e72e3e0
commit da7b7ca1c1
49 changed files with 175 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
call/call.cc
View File

@ -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,
VideoEncoderConfig encoder_config,
std::unique_ptr<FecController> fec_controller) {
VideoSendStream::Config /* config */,
VideoEncoderConfig /* encoder_config */,
std::unique_ptr<FecController> /* fec_controller */) {
return nullptr;
}

2
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -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()) {

2
modules/video_coding/media_opt_util.cc
View File

@ -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

4
modules/video_coding/nack_requester_unittest.cc
View File

@ -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());
}

6
modules/video_coding/rtp_frame_reference_finder.cc
View File

@ -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()(RtpGenericFrameRefFinder& ref_finder) {}
void operator()(RtpFrameIdOnlyRefFinder& ref_finder) {}
void operator()(absl::monostate& /* ref_finder */) {}
void operator()(RtpGenericFrameRefFinder& /* ref_finder */) {}
void operator()(RtpFrameIdOnlyRefFinder& /* ref_finder */) {}
void operator()(RtpSeqNumOnlyRefFinder& ref_finder) {
ref_finder.ClearTo(seq_num);
}

2
modules/video_coding/rtp_frame_reference_finder_unittest.cc
View File

@ -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_;

2
modules/video_coding/utility/simulcast_rate_allocator.cc
View File

@ -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;

34
modules/video_coding/utility/simulcast_test_fixture_impl.cc
View File

@ -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<uint8_t> qp) override {
std::optional<int32_t> /* decode_time_ms */,
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(
::testing::Invoke([&](const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info) {
.WillRepeatedly(::testing::Invoke(
[&](const EncodedImage& encoded_image,
const CodecSpecificInfo* /* codec_specific_info */) {
EXPECT_EQ(encoded_image._frameType, VideoFrameType::kVideoFrameKey);
size_t index = encoded_image.SimulcastIndex().value_or(0);
@ -936,27 +937,30 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() {
EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL));
EXPECT_CALL(decoder_callback, Decoded(_, _, _))
.WillOnce(::testing::Invoke([](VideoFrame& decodedImage,
std::optional<int32_t> decode_time_ms,
std::optional<uint8_t> qp) {
.WillOnce(
::testing::Invoke([](VideoFrame& decodedImage,
std::optional<int32_t> /* decode_time_ms */,
std::optional<uint8_t> /* qp */) {
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,
std::optional<int32_t> decode_time_ms,
std::optional<uint8_t> qp) {
.WillOnce(
::testing::Invoke([](VideoFrame& decodedImage,
std::optional<int32_t> /* decode_time_ms */,
std::optional<uint8_t> /* qp */) {
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,
std::optional<int32_t> decode_time_ms,
std::optional<uint8_t> qp) {
.WillOnce(
::testing::Invoke([](VideoFrame& decodedImage,
std::optional<int32_t> /* decode_time_ms */,
std::optional<uint8_t> /* qp */) {
EXPECT_EQ(decodedImage.width(), kDefaultWidth);
EXPECT_EQ(decodedImage.height(), kDefaultHeight);
}));

4
modules/video_coding/video_coding_defines.cc
View File

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

19
net/dcsctp/fuzzers/dcsctp_fuzzers.h
View File

@ -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 OnError(ErrorKind error, absl::string_view message) override {}
void OnAborted(ErrorKind error, absl::string_view message) override {}
void OnMessageReceived(DcSctpMessage /* message */) override {}
void OnError(ErrorKind /* error */,
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,
absl::string_view reason) override {}
void OnStreamsResetFailed(
rtc::ArrayView<const StreamID> /* outgoing_streams */,
absl::string_view /* reason */) override {}
void OnStreamsResetPerformed(
rtc::ArrayView<const StreamID> outgoing_streams) override {}
void OnIncomingStreamsReset(

16
net/dcsctp/public/dcsctp_socket.h
View File

@ -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,
bool maybe_delivered) {}
virtual void OnLifecycleMessageExpired(LifecycleId /* lifecycle_id */,
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.

2
net/dcsctp/rx/interleaved_reassembly_streams.cc
View File

@ -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) {

8
net/dcsctp/socket/callback_deferrer.cc
View File

@ -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{});

22
net/dcsctp/socket/dcsctp_socket.cc
View File

@ -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);

11
net/dcsctp/socket/dcsctp_socket_network_test.cc
View File

@ -216,18 +216,19 @@ class SctpActor : public DcSctpSocketCallbacks {
void OnConnectionRestarted() override {}
void OnStreamsResetFailed(rtc::ArrayView<const StreamID> outgoing_streams,
absl::string_view reason) override {}
void OnStreamsResetFailed(
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)),

2
net/dcsctp/socket/mock_dcsctp_socket_callbacks.h
View File

@ -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();
}

6
net/dcsctp/socket/stream_reset_handler_test.cc
View File

@ -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) {},
[]() {}, *t3_rtx_timer_, DcSctpOptions(),
"", &callbacks_, kMyInitialTsn, kArwnd, producer_,
[](TimeDelta /* rtt */) {}, []() {}, *t3_rtx_timer_, DcSctpOptions(),
/*supports_partial_reliability=*/true,
/*use_message_interleaving=*/false);
retransmission_queue_->RestoreFromState(state);

2
net/dcsctp/timer/fake_timeout.h
View File

@ -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();
}

6
net/dcsctp/timer/task_queue_timeout_test.cc
View File

@ -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));
}

2
net/dcsctp/tx/mock_send_queue.h
View File

@ -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;
});
}

3
net/dcsctp/tx/retransmission_queue.cc
View File

@ -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

2
net/dcsctp/tx/retransmission_queue_test.cc
View File

@ -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"));
};

3
net/dcsctp/tx/stream_scheduler_test.cc
View File

@ -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),

2
p2p/base/async_stun_tcp_socket.cc
View File

@ -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 =

9
p2p/base/async_stun_tcp_socket_unittest.cc
View File

@ -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,
const rtc::SentPacket& packet) {
void OnSentPacket(rtc::AsyncPacketSocket* /* socket */,
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()));

4
p2p/base/basic_ice_controller.cc
View File

@ -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);

2
p2p/base/connection.cc
View File

@ -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);

9
p2p/base/dtls_transport.cc
View File

@ -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);

2
p2p/base/dtls_transport_internal.h
View File

@ -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;
}

7
p2p/base/dtls_transport_unittest.cc
View File

@ -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,7 +276,8 @@ 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(
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);

2
p2p/base/fake_dtls_transport.h
View File

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

2
p2p/base/fake_ice_transport.h
View File

@ -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;

2
p2p/base/fake_packet_transport.h
View File

@ -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;
}

4
p2p/base/fake_port_allocator.h
View File

@ -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,

4
p2p/base/ice_transport_internal.h
View File

@ -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);

2
p2p/base/mock_active_ice_controller.h
View File

@ -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));

3
p2p/base/mock_ice_controller.h
View File

@ -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));

14
p2p/base/mock_ice_transport.h
View File

@ -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 SetRemoteIceParameters(const IceParameters& ice_params) override {}
void SetRemoteIceMode(IceMode mode) override {}
void SetIceConfig(const IceConfig& config) override {}
void SetIceParameters(const IceParameters& /* ice_params */) override {}
void SetRemoteIceParameters(const IceParameters& /* ice_params */) override {}
void SetRemoteIceMode(IceMode /* mode */) 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 RemoveRemoteCandidate(const Candidate& candidate) override {}
void AddRemoteCandidate(const Candidate& /* candidate */) override {}
void RemoveRemoteCandidate(const Candidate& /* candidate */) override {}
void RemoveAllRemoteCandidates() override {}
IceGatheringState gathering_state() const override {
return IceGatheringState::kIceGatheringComplete;

12
p2p/base/p2p_transport_channel.cc
View File

@ -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) {

2
p2p/base/p2p_transport_channel_unittest.cc
View File

@ -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_));

3
p2p/base/packet_transport_internal.cc
View File

@ -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;
}

4
p2p/base/port.cc
View File

@ -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,
const rtc::ReceivedPacket& packet) {
bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* /* socket */,
const rtc::ReceivedPacket& /* packet */) {
RTC_DCHECK_NOTREACHED();
return false;
}

4
p2p/base/port.h
View File

@ -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();

7
p2p/base/port_allocator.h
View File

@ -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,

12
p2p/base/port_unittest.cc
View File

@ -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::PacketOptions& options,
const rtc::SocketAddress& /* addr */,
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() {

4
p2p/base/pseudo_tcp_unittest.cc
View File

@ -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];

2
p2p/base/regathering_controller_unittest.cc
View File

@ -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];
}

14
p2p/base/stun_port.cc
View File

@ -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();
}

10
p2p/base/stun_port_unittest.cc
View File

@ -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));