Fix Chromium clang plugin warnings

BUG=webrtc:163

Review-Url: https://codereview.webrtc.org/2288593004
Cr-Commit-Position: refs/heads/master@{#13961}

webrtc/common_audio/blocker.cc

@@ -125,6 +125,8 @@ Blocker::Blocker(size_t chunk_size,
   input_buffer_.MoveReadPositionBackward(initial_delay_);
 }
 
+Blocker::~Blocker() = default;
+
 // When block_size < chunk_size the input and output buffers look like this:
 //
 //                      delay*             chunk_size    chunk_size + delay*

webrtc/common_audio/blocker.h

@@ -71,6 +71,7 @@ class Blocker {
           const float* window,
           size_t shift_amount,
           BlockerCallback* callback);
+  ~Blocker();
 
   void ProcessChunk(const float* const* input,
                     size_t chunk_size,

webrtc/common_audio/channel_buffer.cc

@@ -22,6 +22,8 @@ IFChannelBuffer::IFChannelBuffer(size_t num_frames,
       fvalid_(true),
       fbuf_(num_frames, num_channels, num_bands) {}
 
+IFChannelBuffer::~IFChannelBuffer() = default;
+
 ChannelBuffer<int16_t>* IFChannelBuffer::ibuf() {
   RefreshI();
   fvalid_ = false;

webrtc/common_audio/channel_buffer.h

@@ -153,6 +153,7 @@ class ChannelBuffer {
 class IFChannelBuffer {
  public:
   IFChannelBuffer(size_t num_frames, size_t num_channels, size_t num_bands = 1);
+  ~IFChannelBuffer();
 
   ChannelBuffer<int16_t>* ibuf();
   ChannelBuffer<float>* fbuf();

webrtc/common_audio/lapped_transform.cc

@@ -92,6 +92,8 @@ LappedTransform::LappedTransform(size_t num_in_channels,
   RTC_CHECK_EQ(0u, block_length_ & (block_length_ - 1));
 }
 
+LappedTransform::~LappedTransform() = default;
+
 void LappedTransform::ProcessChunk(const float* const* in_chunk,
                                    float* const* out_chunk) {
   blocker_.ProcessChunk(in_chunk, chunk_length_, num_in_channels_,

webrtc/common_audio/lapped_transform.h

@@ -53,7 +53,7 @@ class LappedTransform {
                   size_t block_length,
                   size_t shift_amount,
                   Callback* callback);
-  ~LappedTransform() {}
+  ~LappedTransform();
 
   // Main audio processing helper method. Internally slices |in_chunk| into
   // blocks, transforms them to frequency domain, calls the callback for each
@@ -93,11 +93,11 @@ class LappedTransform {
    public:
     explicit BlockThunk(LappedTransform* parent) : parent_(parent) {}
 
-    virtual void ProcessBlock(const float* const* input,
+ void ProcessBlock(const float* const* input,
                               size_t num_frames,
                               size_t num_input_channels,
                               size_t num_output_channels,
-                              float* const* output);
+                              float* const* output) override;
 
    private:
     LappedTransform* const parent_;

webrtc/modules/audio_processing/BUILD.gn

@@ -479,10 +479,6 @@ if (rtc_include_tests) {
       "../../system_wrappers:metrics_default",
       "//third_party/gflags",
     ]
-    if (is_clang) {
-      # Suppress warnings from the Chromium Clang plugins (bugs.webrtc.org/163).
-      configs -= [ "//build/config/clang:find_bad_constructs" ]
-    }
   }
 
   if (rtc_enable_intelligibility_enhancer) {

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.cc

@@ -222,6 +222,8 @@ NonlinearBeamformer::NonlinearBeamformer(
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, kFftSize, window_);
 }
 
+NonlinearBeamformer::~NonlinearBeamformer() = default;
+
 void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
   chunk_length_ =
       static_cast<size_t>(sample_rate_hz / (1000.f / chunk_size_ms));
@@ -438,6 +440,8 @@ bool NonlinearBeamformer::IsInBeam(const SphericalPointf& spherical_point) {
          kHalfBeamWidthRadians;
 }
 
+bool NonlinearBeamformer::is_target_present() { return is_target_present_; }
+
 void NonlinearBeamformer::ProcessAudioBlock(const complex_f* const* input,
                                             size_t num_input_channels,
                                             size_t num_freq_bins,

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h

@@ -63,6 +63,7 @@ class NonlinearBeamformer : public LappedTransform::Callback {
       size_t num_postfilter_channels = 1u,
       SphericalPointf target_direction =
           SphericalPointf(static_cast<float>(M_PI) / 2.f, 0.f, 1.f));
+  ~NonlinearBeamformer() override;
 
   // Sample rate corresponds to the lower band.
   // Needs to be called before the NonlinearBeamformer can be used.
@@ -86,7 +87,7 @@ class NonlinearBeamformer : public LappedTransform::Callback {
   // target signal es present and to false otherwise. This methods can be called
   // to know if the data is target signal or interference and process it
   // accordingly.
-  virtual bool is_target_present() { return is_target_present_; }
+  virtual bool is_target_present();
 
  protected:
   // Process one frequency-domain block of audio. This is where the fun

webrtc/modules/audio_processing/test/test_utils.cc

@@ -36,6 +36,8 @@ void RawFile::WriteSamples(const float* samples, size_t num_samples) {
 ChannelBufferWavReader::ChannelBufferWavReader(std::unique_ptr<WavReader> file)
     : file_(std::move(file)) {}
 
+ChannelBufferWavReader::~ChannelBufferWavReader() = default;
+
 bool ChannelBufferWavReader::Read(ChannelBuffer<float>* buffer) {
   RTC_CHECK_EQ(file_->num_channels(), buffer->num_channels());
   interleaved_.resize(buffer->size());
@@ -53,6 +55,8 @@ bool ChannelBufferWavReader::Read(ChannelBuffer<float>* buffer) {
 ChannelBufferWavWriter::ChannelBufferWavWriter(std::unique_ptr<WavWriter> file)
     : file_(std::move(file)) {}
 
+ChannelBufferWavWriter::~ChannelBufferWavWriter() = default;
+
 void ChannelBufferWavWriter::Write(const ChannelBuffer<float>& buffer) {
   RTC_CHECK_EQ(file_->num_channels(), buffer.num_channels());
   interleaved_.resize(buffer.size());

webrtc/modules/audio_processing/test/test_utils.h

@@ -47,6 +47,7 @@ class RawFile final {
 class ChannelBufferWavReader final {
  public:
   explicit ChannelBufferWavReader(std::unique_ptr<WavReader> file);
+  ~ChannelBufferWavReader();
 
   // Reads data from the file according to the |buffer| format. Returns false if
   // a full buffer can't be read from the file.
@@ -63,6 +64,8 @@ class ChannelBufferWavReader final {
 class ChannelBufferWavWriter final {
  public:
   explicit ChannelBufferWavWriter(std::unique_ptr<WavWriter> file);
+  ~ChannelBufferWavWriter();
+
   void Write(const ChannelBuffer<float>& buffer);
 
  private: