Revert "Comment unused variables in implemented functions"

This reverts commit 05043e1cef47f33e81bc7ba83b4cc2c407111397.

Reason for revert: breaks compilation of .c files

Original change's description:
> Comment unused variables in implemented functions
>
> Compiling webrtc with `-Werror=unused-parameters` is failling duo to
> those parameters.
> Also, it shouldn't harm us to put those in comment for code readability as
> well.
>
> Bug: webrtc:370878648
> Change-Id: I0ab2eafd26e46312e4595f302b92006c9e23d5d2
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/364340
> Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
> Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
> Reviewed-by: Harald Alvestrand <hta@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#43157}

Bug: webrtc:370878648
Change-Id: I4ea50baa2c3d0d162759c8255171e95c6199ed26
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/364580
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Owners-Override: Danil Chapovalov <danilchap@webrtc.org>
Auto-Submit: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43162}

api/array_view.h

@@ -97,7 +97,7 @@ class ArrayViewBase {
   static_assert(Size > 0, "ArrayView size must be variable or non-negative");
 
  public:
-  ArrayViewBase(T* data, size_t /* size */) : data_(data) {}
+  ArrayViewBase(T* data, size_t size) : data_(data) {}
 
   static constexpr size_t size() { return Size; }
   static constexpr bool empty() { return false; }
@@ -114,7 +114,7 @@ class ArrayViewBase {
 template <typename T>
 class ArrayViewBase<T, 0> {
  public:
-  explicit ArrayViewBase(T* /* data */, size_t /* size */) {}
+  explicit ArrayViewBase(T* data, size_t size) {}
 
   static constexpr size_t size() { return 0; }
   static constexpr bool empty() { return true; }

api/dtmf_sender_interface.h

@@ -27,12 +27,12 @@ class DtmfSenderObserverInterface {
   // tones.
   // The callback includes the state of the tone buffer at the time when
   // the tone finished playing.
-  virtual void OnToneChange(const std::string& /* tone */,
+  virtual void OnToneChange(const std::string& tone,
-                            const std::string& /* tone_buffer */) {}
+                            const std::string& tone_buffer) {}
   // DEPRECATED: Older API without tone buffer.
   // TODO(bugs.webrtc.org/9725): Remove old API and default implementation
   // when old callers are gone.
-  virtual void OnToneChange(const std::string& /* tone */) {}
+  virtual void OnToneChange(const std::string& tone) {}
 
  protected:
   virtual ~DtmfSenderObserverInterface() = default;
@@ -91,7 +91,7 @@ class DtmfSenderInterface : public webrtc::RefCountInterface {
   virtual bool InsertDtmf(const std::string& tones,
                           int duration,
                           int inter_tone_gap,
-                          int /* comma_delay */) {
+                          int comma_delay) {
     // TODO(bugs.webrtc.org/165700): Remove once downstream implementations
     // override this signature rather than the 3-parameter one.
     return InsertDtmf(tones, duration, inter_tone_gap);

api/frame_transformer_interface.h

@@ -139,9 +139,9 @@ class FrameTransformerInterface : public RefCountInterface {
       rtc::scoped_refptr<TransformedFrameCallback>) {}
   virtual void RegisterTransformedFrameSinkCallback(
       rtc::scoped_refptr<TransformedFrameCallback>,
-      uint32_t /* ssrc */) {}
+      uint32_t ssrc) {}
   virtual void UnregisterTransformedFrameCallback() {}
-  virtual void UnregisterTransformedFrameSinkCallback(uint32_t /* ssrc */) {}
+  virtual void UnregisterTransformedFrameSinkCallback(uint32_t ssrc) {}
 
  protected:
   ~FrameTransformerInterface() override = default;

api/function_view.h

@@ -86,7 +86,7 @@ class FunctionView<RetT(ArgT...)> final {
             typename std::enable_if<std::is_same<
                 std::nullptr_t,
                 typename std::remove_cv<F>::type>::value>::type* = nullptr>
-  FunctionView(F&& /* f */) : call_(nullptr) {}
+  FunctionView(F&& f) : call_(nullptr) {}
 
   // Default constructor. Creates an empty FunctionView.
   FunctionView() : call_(nullptr) {}

api/media_stream_interface.h

@@ -161,7 +161,7 @@ class VideoTrackSourceInterface : public MediaSourceInterface,
   // The call is expected to happen on the network thread.
   // TODO(crbug/1255737): make pure virtual once downstream project adapts.
   virtual void ProcessConstraints(
-      const webrtc::VideoTrackSourceConstraints& /* constraints */) {}
+      const webrtc::VideoTrackSourceConstraints& constraints) {}
 
  protected:
   ~VideoTrackSourceInterface() override = default;
@@ -184,14 +184,14 @@ class RTC_EXPORT VideoTrackInterface
 
   // Register a video sink for this track. Used to connect the track to the
   // underlying video engine.
-  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* /* sink */,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
-                       const rtc::VideoSinkWants& /* wants */) override {}
+                       const rtc::VideoSinkWants& wants) override {}
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* /* sink */) override {}
+  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {}
 
   virtual VideoTrackSourceInterface* GetSource() const = 0;
 
   virtual ContentHint content_hint() const;
-  virtual void set_content_hint(ContentHint /* hint */) {}
+  virtual void set_content_hint(ContentHint hint) {}
 
  protected:
   ~VideoTrackInterface() override = default;
@@ -200,11 +200,11 @@ class RTC_EXPORT VideoTrackInterface
 // Interface for receiving audio data from a AudioTrack.
 class AudioTrackSinkInterface {
  public:
-  virtual void OnData(const void* /* audio_data */,
+  virtual void OnData(const void* audio_data,
-                      int /* bits_per_sample */,
+                      int bits_per_sample,
-                      int /* sample_rate */,
+                      int sample_rate,
-                      size_t /* number_of_channels */,
+                      size_t number_of_channels,
-                      size_t /* number_of_frames */) {
+                      size_t number_of_frames) {
     RTC_DCHECK_NOTREACHED() << "This method must be overridden, or not used.";
   }
 
@@ -212,13 +212,12 @@ class AudioTrackSinkInterface {
   // supposed to deliver the timestamp when this audio frame was originally
   // captured. This timestamp MUST be based on the same clock as
   // rtc::TimeMillis().
-  virtual void OnData(
+  virtual void OnData(const void* audio_data,
-      const void* audio_data,
+                      int bits_per_sample,
-      int bits_per_sample,
+                      int sample_rate,
-      int sample_rate,
+                      size_t number_of_channels,
-      size_t number_of_channels,
+                      size_t number_of_frames,
-      size_t number_of_frames,
+                      std::optional<int64_t> absolute_capture_timestamp_ms) {
-      std::optional<int64_t> /* absolute_capture_timestamp_ms */) {
     // TODO(bugs.webrtc.org/10739): Deprecate the old OnData and make this one
     // pure virtual.
     return OnData(audio_data, bits_per_sample, sample_rate, number_of_channels,
@@ -252,15 +251,15 @@ class RTC_EXPORT AudioSourceInterface : public MediaSourceInterface {
   // Sets the volume of the source. `volume` is in  the range of [0, 10].
   // TODO(tommi): This method should be on the track and ideally volume should
   // be applied in the track in a way that does not affect clones of the track.
-  virtual void SetVolume(double /* volume */) {}
+  virtual void SetVolume(double volume) {}
 
   // Registers/unregisters observers to the audio source.
-  virtual void RegisterAudioObserver(AudioObserver* /* observer */) {}
+  virtual void RegisterAudioObserver(AudioObserver* observer) {}
-  virtual void UnregisterAudioObserver(AudioObserver* /* observer */) {}
+  virtual void UnregisterAudioObserver(AudioObserver* observer) {}
 
   // TODO(tommi): Make pure virtual.
-  virtual void AddSink(AudioTrackSinkInterface* /* sink */) {}
+  virtual void AddSink(AudioTrackSinkInterface* sink) {}
-  virtual void RemoveSink(AudioTrackSinkInterface* /* sink */) {}
+  virtual void RemoveSink(AudioTrackSinkInterface* sink) {}
 
   // Returns options for the AudioSource.
   // (for some of the settings this approach is broken, e.g. setting
@@ -340,18 +339,16 @@ class MediaStreamInterface : public webrtc::RefCountInterface,
   // Note: Default implementations are for avoiding link time errors in
   // implementations that mock this API.
   // TODO(bugs.webrtc.org/13980): Remove default implementations.
-  virtual bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> /* track */) {
+  virtual bool AddTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
     RTC_CHECK_NOTREACHED();
   }
-  virtual bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> /* track */) {
+  virtual bool AddTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
     RTC_CHECK_NOTREACHED();
   }
-  virtual bool RemoveTrack(
+  virtual bool RemoveTrack(rtc::scoped_refptr<AudioTrackInterface> track) {
-      rtc::scoped_refptr<AudioTrackInterface> /* track */) {
     RTC_CHECK_NOTREACHED();
   }
-  virtual bool RemoveTrack(
+  virtual bool RemoveTrack(rtc::scoped_refptr<VideoTrackInterface> track) {
-      rtc::scoped_refptr<VideoTrackInterface> /* track */) {
     RTC_CHECK_NOTREACHED();
   }
 

api/rtc_event_log/rtc_event_log.h

@@ -60,7 +60,7 @@ class RtcEventLogNull final : public RtcEventLog {
   bool StartLogging(std::unique_ptr<RtcEventLogOutput> output,
                     int64_t output_period_ms) override;
   void StopLogging() override {}
-  void Log(std::unique_ptr<RtcEvent> /* event */) override {}
+  void Log(std::unique_ptr<RtcEvent> event) override {}
 };
 
 }  // namespace webrtc

api/rtp_receiver_interface.h

@@ -80,9 +80,7 @@ class RTC_EXPORT RtpReceiverInterface : public webrtc::RefCountInterface,
   virtual RtpParameters GetParameters() const = 0;
   // TODO(dinosaurav): Delete SetParameters entirely after rolling to Chromium.
   // Currently, doesn't support changing any parameters.
-  virtual bool SetParameters(const RtpParameters& /* parameters */) {
+  virtual bool SetParameters(const RtpParameters& parameters) { return false; }
-    return false;
-  }
 
   // Does not take ownership of observer.
   // Must call SetObserver(nullptr) before the observer is destroyed.

api/rtp_sender_interface.h

@@ -119,7 +119,7 @@ class RTC_EXPORT RtpSenderInterface : public webrtc::RefCountInterface,
   // Default implementation of SetFrameTransformer.
   // TODO: bugs.webrtc.org/15929 - remove when all implementations are good
   void SetFrameTransformer(rtc::scoped_refptr<FrameTransformerInterface>
-                           /* frame_transformer */) override {}
+                               frame_transformer) override {}
 
  protected:
   ~RtpSenderInterface() override = default;

api/transport/data_channel_transport_interface.h

@@ -88,7 +88,7 @@ class DataChannelSink {
   // Callback issued when the data channel becomes unusable (closed).
   // TODO(https://crbug.com/webrtc/10360): Make pure virtual when all
   // consumers updated.
-  virtual void OnTransportClosed(RTCError /* error */) {}
+  virtual void OnTransportClosed(RTCError error) {}
 
   // The data channel's buffered_amount has fallen to or below the threshold
   // set when calling `SetBufferedAmountLowThreshold`

api/video/video_sink_interface.h

@@ -29,7 +29,7 @@ class VideoSinkInterface {
   // Called on the network thread when video constraints change.
   // TODO(crbug/1255737): make pure virtual once downstream project adapts.
   virtual void OnConstraintsChanged(
-      const webrtc::VideoTrackSourceConstraints& /* constraints */) {}
+      const webrtc::VideoTrackSourceConstraints& constraints) {}
 };
 
 }  // namespace rtc

api/video_codecs/video_decoder.h

@@ -107,7 +107,7 @@ class RTC_EXPORT VideoDecoder {
   // TODO(bugs.webrtc.org/15444): Migrate all subclasses to Decode() without
   // missing_frame and delete this.
   virtual int32_t Decode(const EncodedImage& input_image,
-                         bool /* missing_frames */,
+                         bool missing_frames,
                          int64_t render_time_ms) {
     return Decode(input_image, render_time_ms);
   }

api/video_codecs/video_encoder.h

@@ -82,7 +82,7 @@ class RTC_EXPORT EncodedImageCallback {
       const EncodedImage& encoded_image,
       const CodecSpecificInfo* codec_specific_info) = 0;
 
-  virtual void OnDroppedFrame(DropReason /* reason */) {}
+  virtual void OnDroppedFrame(DropReason reason) {}
 };
 
 class RTC_EXPORT VideoEncoder {

api/video_codecs/video_encoder_factory.h

@@ -54,7 +54,7 @@ class VideoEncoderFactory {
     // Called every time the encoder input resolution change. Should return a
     // non-empty if an encoder switch should be performed.
     virtual std::optional<SdpVideoFormat> OnResolutionChange(
-        const RenderResolution& /* resolution */) {
+        const RenderResolution& resolution) {
       return std::nullopt;
     }
 

media/base/media_channel.h

@@ -246,9 +246,9 @@ class MediaSendChannelInterface {
   // note: The encoder_selector object must remain valid for the lifetime of the
   // MediaChannel, unless replaced.
   virtual void SetEncoderSelector(
-      uint32_t /* ssrc */,
+      uint32_t ssrc,
-      webrtc::VideoEncoderFactory::
+      webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) {
-          EncoderSelectorInterface* /* encoder_selector */) {}
+  }
   virtual webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const = 0;
   virtual bool SendCodecHasNack() const = 0;
   // Called whenever the list of sending SSRCs changes.

modules/rtp_rtcp/include/rtp_rtcp_defines.h

@@ -168,22 +168,20 @@ class NetworkLinkRtcpObserver {
  public:
   virtual ~NetworkLinkRtcpObserver() = default;
 
-  virtual void OnTransportFeedback(
+  virtual void OnTransportFeedback(Timestamp receive_time,
-      Timestamp /* receive_time */,
+                                   const rtcp::TransportFeedback& feedback) {}
-      const rtcp::TransportFeedback& /* feedback */) {}
   // RFC 8888 congestion control feedback.
   virtual void OnCongestionControlFeedback(
-      Timestamp /* receive_time */,
+      Timestamp receive_time,
-      const rtcp::CongestionControlFeedback& /* feedback */) {}
+      const rtcp::CongestionControlFeedback& feedback) {}
-  virtual void OnReceiverEstimatedMaxBitrate(Timestamp /* receive_time */,
+  virtual void OnReceiverEstimatedMaxBitrate(Timestamp receive_time,
-                                             DataRate /* bitrate */) {}
+                                             DataRate bitrate) {}
 
   // Called on an RTCP packet with sender or receiver reports with non zero
   // report blocks. Report blocks are combined from all reports into one array.
-  virtual void OnReport(
+  virtual void OnReport(Timestamp receive_time,
-      Timestamp /* receive_time */,
+                        rtc::ArrayView<const ReportBlockData> report_blocks) {}
-      rtc::ArrayView<const ReportBlockData> /* report_blocks */) {}
+  virtual void OnRttUpdate(Timestamp receive_time, TimeDelta rtt) {}
-  virtual void OnRttUpdate(Timestamp /* receive_time */, TimeDelta /* rtt */) {}
 };
 
 // NOTE! `kNumMediaTypes` must be kept in sync with RtpPacketMediaType!

rtc_base/checks.cc

@@ -78,8 +78,8 @@ RTC_NORETURN void WriteFatalLog(absl::string_view output) {
   abort();
 }
 
-RTC_NORETURN void WriteFatalLog(const char* /* file */,
+RTC_NORETURN void WriteFatalLog(const char* file,
-                                int /* line */,
+                                int line,
                                 absl::string_view output) {
   WriteFatalLog(output);
 }

rtc_base/crypto_random.cc

@@ -34,7 +34,7 @@ class SecureRandomGenerator : public RandomGenerator {
  public:
   SecureRandomGenerator() {}
   ~SecureRandomGenerator() override {}
-  bool Init(const void* /* seed */, size_t /* len */) override { return true; }
+  bool Init(const void* seed, size_t len) override { return true; }
   bool Generate(void* buf, size_t len) override {
     return (RAND_bytes(reinterpret_cast<unsigned char*>(buf), len) > 0);
   }
@@ -45,7 +45,7 @@ class TestRandomGenerator : public RandomGenerator {
  public:
   TestRandomGenerator() : seed_(7) {}
   ~TestRandomGenerator() override {}
-  bool Init(const void* /* seed */, size_t /* len */) override { return true; }
+  bool Init(const void* seed, size_t len) override { return true; }
   bool Generate(void* buf, size_t len) override {
     for (size_t i = 0; i < len; ++i) {
       static_cast<uint8_t*>(buf)[i] = static_cast<uint8_t>(GetRandom());

rtc_base/logging.cc

@@ -220,7 +220,7 @@ LogMessage::~LogMessage() {
   }
 }
 
-void LogMessage::AddTag([[maybe_unused]] const char* tag) {
+void LogMessage::AddTag(const char* tag) {
 #ifdef WEBRTC_ANDROID
   log_line_.set_tag(tag);
 #endif

rtc_base/logging.h

@@ -466,7 +466,7 @@ class LogMessageVoidify {
   // This has to be an operator with a precedence lower than << but
   // higher than ?:
   template <typename... Ts>
-  void operator&(LogStreamer<Ts...>&& /* streamer */) {}
+  void operator&(LogStreamer<Ts...>&& streamer) {}
 };
 
 }  // namespace webrtc_logging_impl

rtc_base/numerics/safe_conversions_impl.h

@@ -101,9 +101,7 @@ struct RangeCheckImpl {};
 // Dst range always contains the result: nothing to check.
 template <typename Dst, typename Src, DstSign IsDstSigned, SrcSign IsSrcSigned>
 struct RangeCheckImpl<Dst, Src, IsDstSigned, IsSrcSigned, CONTAINS_RANGE> {
-  static constexpr RangeCheckResult Check(Src /* value */) {
+  static constexpr RangeCheckResult Check(Src value) { return TYPE_VALID; }
-    return TYPE_VALID;
-  }
 };
 
 // Signed to signed narrowing.

rtc_base/sanitizer.h

@@ -51,9 +51,9 @@
 // Ask ASan to mark the memory range [ptr, ptr + element_size * num_elements)
 // as being unaddressable, so that reads and writes are not allowed. ASan may
 // narrow the range to the nearest alignment boundaries.
-static inline void rtc_AsanPoison([[maybe_unused]] const volatile void* ptr,
+static inline void rtc_AsanPoison(const volatile void* ptr,
-                                  [[maybe_unused]] size_t element_size,
+                                  size_t element_size,
-                                  [[maybe_unused]] size_t num_elements) {
+                                  size_t num_elements) {
 #if RTC_HAS_ASAN
   ASAN_POISON_MEMORY_REGION(ptr, element_size * num_elements);
 #endif
@@ -62,9 +62,9 @@ static inline void rtc_AsanPoison([[maybe_unused]] const volatile void* ptr,
 // Ask ASan to mark the memory range [ptr, ptr + element_size * num_elements)
 // as being addressable, so that reads and writes are allowed. ASan may widen
 // the range to the nearest alignment boundaries.
-static inline void rtc_AsanUnpoison([[maybe_unused]] const volatile void* ptr,
+static inline void rtc_AsanUnpoison(const volatile void* ptr,
-                                    [[maybe_unused]] size_t element_size,
+                                    size_t element_size,
-                                    [[maybe_unused]] size_t num_elements) {
+                                    size_t num_elements) {
 #if RTC_HAS_ASAN
   ASAN_UNPOISON_MEMORY_REGION(ptr, element_size * num_elements);
 #endif
@@ -72,10 +72,9 @@ static inline void rtc_AsanUnpoison([[maybe_unused]] const volatile void* ptr,
 
 // Ask MSan to mark the memory range [ptr, ptr + element_size * num_elements)
 // as being uninitialized.
-static inline void rtc_MsanMarkUninitialized(
+static inline void rtc_MsanMarkUninitialized(const volatile void* ptr,
-    [[maybe_unused]] const volatile void* ptr,
+                                             size_t element_size,
-    [[maybe_unused]] size_t element_size,
+                                             size_t num_elements) {
-    [[maybe_unused]] size_t num_elements) {
 #if RTC_HAS_MSAN
   __msan_poison(ptr, element_size * num_elements);
 #endif
@@ -84,10 +83,9 @@ static inline void rtc_MsanMarkUninitialized(
 // Force an MSan check (if any bits in the memory range [ptr, ptr +
 // element_size * num_elements) are uninitialized the call will crash with an
 // MSan report).
-static inline void rtc_MsanCheckInitialized(
+static inline void rtc_MsanCheckInitialized(const volatile void* ptr,
-    [[maybe_unused]] const volatile void* ptr,
+                                            size_t element_size,
-    [[maybe_unused]] size_t element_size,
+                                            size_t num_elements) {
-    [[maybe_unused]] size_t num_elements) {
 #if RTC_HAS_MSAN
   __msan_check_mem_is_initialized(ptr, element_size * num_elements);
 #endif

rtc_base/socket.h

@@ -113,10 +113,10 @@ class RTC_EXPORT Socket {
   // `timestamp` is in units of microseconds.
   virtual int Recv(void* pv, size_t cb, int64_t* timestamp) = 0;
   // TODO(webrtc:15368): Deprecate and remove.
-  virtual int RecvFrom(void* /* pv */,
+  virtual int RecvFrom(void* pv,
-                       size_t /* cb */,
+                       size_t cb,
-                       SocketAddress* /* paddr */,
+                       SocketAddress* paddr,
-                       int64_t* /* timestamp */) {
+                       int64_t* timestamp) {
     // Not implemented. Use RecvFrom(ReceiveBuffer& buffer).
     RTC_CHECK_NOTREACHED();
   }

rtc_base/string_to_number.h

@@ -92,7 +92,7 @@ StringToNumber(absl::string_view str, int base = 10) {
 template <typename T>
 typename std::enable_if<std::is_floating_point<T>::value,
                         std::optional<T>>::type
-StringToNumber(absl::string_view str, int /* base */ = 10) {
+StringToNumber(absl::string_view str, int base = 10) {
   static_assert(
       std::numeric_limits<T>::max() <= std::numeric_limits<long double>::max(),
       "StringToNumber only supports floating-point numbers as large "

rtc_base/synchronization/sequence_checker_internal.h

@@ -59,8 +59,8 @@ class RTC_EXPORT SequenceCheckerImpl {
 // right version for your build configuration.
 class SequenceCheckerDoNothing {
  public:
-  explicit SequenceCheckerDoNothing(bool /* attach_to_current_thread */) {}
+  explicit SequenceCheckerDoNothing(bool attach_to_current_thread) {}
-  explicit SequenceCheckerDoNothing(TaskQueueBase* /* attached_queue */) {}
+  explicit SequenceCheckerDoNothing(TaskQueueBase* attached_queue) {}
   bool IsCurrent() const { return true; }
   void Detach() {}
 };
@@ -68,7 +68,7 @@ class SequenceCheckerDoNothing {
 template <typename ThreadLikeObject>
 std::enable_if_t<std::is_base_of_v<SequenceCheckerImpl, ThreadLikeObject>,
                  std::string>
-ExpectationToString([[maybe_unused]] const ThreadLikeObject* checker) {
+ExpectationToString(const ThreadLikeObject* checker) {
 #if RTC_DCHECK_IS_ON
   return checker->ExpectationToString();
 #else