Update {virtual,override,final} to follow C++11 style.

media/audio/android/audio_android_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 154 matching lines @@
       : event_(event), pos_(0) {
     // Reads a test file from media/test/data directory and stores it in
     // a DecoderBuffer.
     file_ = ReadTestDataFile(name);
 
     // Log the name of the file which is used as input for this test.
     base::FilePath file_path = GetTestDataFilePath(name);
     DVLOG(0) << "Reading from file: " << file_path.value().c_str();
   }
 
-  virtual ~FileAudioSource() {}
+  ~FileAudioSource() override {}
 
   // AudioOutputStream::AudioSourceCallback implementation.
 
   // Use samples read from a data file and fill up the audio buffer
   // provided to us in the callback.
-  virtual int OnMoreData(AudioBus* audio_bus,
-                         uint32 total_bytes_delay) override {
+  int OnMoreData(AudioBus* audio_bus, uint32 total_bytes_delay) override {
     bool stop_playing = false;
     int max_size =
         audio_bus->frames() * audio_bus->channels() * kBytesPerSample;
 
     // Adjust data size and prepare for end signal if file has ended.
     if (pos_ + max_size > file_size()) {
       stop_playing = true;
       max_size = file_size() - pos_;
     }
 
     // File data is stored as interleaved 16-bit values. Copy data samples from
     // the file and deinterleave to match the audio bus format.
     // FromInterleaved() will zero out any unfilled frames when there is not
     // sufficient data remaining in the file to fill up the complete frame.
     int frames = max_size / (audio_bus->channels() * kBytesPerSample);
     if (max_size) {
       audio_bus->FromInterleaved(file_->data() + pos_, frames, kBytesPerSample);
       pos_ += max_size;
     }
 
     // Set event to ensure that the test can stop when the file has ended.
     if (stop_playing)
       event_->Signal();
 
     return frames;
   }
 
-  virtual void OnError(AudioOutputStream* stream) override {}
+  void OnError(AudioOutputStream* stream) override {}
 
   int file_size() { return file_->data_size(); }
 
  private:
   base::WaitableEvent* event_;
   int pos_;
   scoped_refptr<DecoderBuffer> file_;
 
   DISALLOW_COPY_AND_ASSIGN(FileAudioSource);
 };
@@ skipping 15 matching lines @@
 
     // Open up the binary file which will be written to in the destructor.
     base::FilePath file_path;
     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
     file_path = file_path.AppendASCII(file_name.c_str());
     binary_file_ = base::OpenFile(file_path, "wb");
     DLOG_IF(ERROR, !binary_file_) << "Failed to open binary PCM data file.";
     DVLOG(0) << "Writing to file: " << file_path.value().c_str();
   }
 
-  virtual ~FileAudioSink() {
+  ~FileAudioSink() override {
     int bytes_written = 0;
     while (bytes_written < buffer_->forward_capacity()) {
       const uint8* chunk;
       int chunk_size;
 
       // Stop writing if no more data is available.
       if (!buffer_->GetCurrentChunk(&chunk, &chunk_size))
         break;
 
       // Write recorded data chunk to the file and prepare for next chunk.
       // TODO(henrika): use file_util:: instead.
       fwrite(chunk, 1, chunk_size, binary_file_);
       buffer_->Seek(chunk_size);
       bytes_written += chunk_size;
     }
     base::CloseFile(binary_file_);
   }
 
   // AudioInputStream::AudioInputCallback implementation.
-  virtual void OnData(AudioInputStream* stream,
-                      const AudioBus* src,
-                      uint32 hardware_delay_bytes,
-                      double volume) override {
+  void OnData(AudioInputStream* stream,
+              const AudioBus* src,
+              uint32 hardware_delay_bytes,
+              double volume) override {
     const int num_samples = src->frames() * src->channels();
     scoped_ptr<int16> interleaved(new int16[num_samples]);
     const int bytes_per_sample = sizeof(*interleaved);
     src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
 
     // Store data data in a temporary buffer to avoid making blocking
     // fwrite() calls in the audio callback. The complete buffer will be
     // written to file in the destructor.
     const int size = bytes_per_sample * num_samples;
     if (!buffer_->Append((const uint8*)interleaved.get(), size))
       event_->Signal();
   }
 
-  virtual void OnError(AudioInputStream* stream) override {}
+  void OnError(AudioInputStream* stream) override {}
 
  private:
   base::WaitableEvent* event_;
   AudioParameters params_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   FILE* binary_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FileAudioSink);
 };
 
 // Implements AudioInputCallback and AudioSourceCallback to support full
 // duplex audio where captured samples are played out in loopback after
 // reading from a temporary FIFO storage.
 class FullDuplexAudioSinkSource
     : public AudioInputStream::AudioInputCallback,
       public AudioOutputStream::AudioSourceCallback {
  public:
   explicit FullDuplexAudioSinkSource(const AudioParameters& params)
       : params_(params),
         previous_time_(base::TimeTicks::Now()),
         started_(false) {
     // Start with a reasonably small FIFO size. It will be increased
     // dynamically during the test if required.
     fifo_.reset(new media::SeekableBuffer(0, 2 * params.GetBytesPerBuffer()));
     buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
   }
 
-  virtual ~FullDuplexAudioSinkSource() {}
+  ~FullDuplexAudioSinkSource() override {}
 
   // AudioInputStream::AudioInputCallback implementation
-  virtual void OnData(AudioInputStream* stream,
-                      const AudioBus* src,
-                      uint32 hardware_delay_bytes,
-                      double volume) override {
+  void OnData(AudioInputStream* stream,
+              const AudioBus* src,
+              uint32 hardware_delay_bytes,
+              double volume) override {
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_time_).InMilliseconds();
 
     EXPECT_EQ(params_.bits_per_sample(), 16);
     const int num_samples = src->frames() * src->channels();
     scoped_ptr<int16> interleaved(new int16[num_samples]);
     const int bytes_per_sample = sizeof(*interleaved);
     src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
     const int size = bytes_per_sample * num_samples;
 
@@ skipping 16 matching lines @@
       return;
 
     // Append new data to the FIFO and extend the size if the max capacity
     // was exceeded. Flush the FIFO when extended just in case.
     if (!fifo_->Append((const uint8*)interleaved.get(), size)) {
       fifo_->set_forward_capacity(2 * fifo_->forward_capacity());
       fifo_->Clear();
     }
   }
 
-  virtual void OnError(AudioInputStream* stream) override {}
+  void OnError(AudioInputStream* stream) override {}
 
   // AudioOutputStream::AudioSourceCallback implementation
-  virtual int OnMoreData(AudioBus* dest,
-                         uint32 total_bytes_delay) override {
+  int OnMoreData(AudioBus* dest, uint32 total_bytes_delay) override {
     const int size_in_bytes =
         (params_.bits_per_sample() / 8) * dest->frames() * dest->channels();
     EXPECT_EQ(size_in_bytes, params_.GetBytesPerBuffer());
 
     base::AutoLock lock(lock_);
 
     // We add an initial delay of ~1 second before loopback starts to ensure
     // a stable callback sequences and to avoid initial bursts which might add
     // to the extra FIFO delay.
     if (!started_) {
       dest->Zero();
       return dest->frames();
     }
 
     // Fill up destination with zeros if the FIFO does not contain enough
     // data to fulfill the request.
     if (fifo_->forward_bytes() < size_in_bytes) {
       dest->Zero();
     } else {
       fifo_->Read(buffer_.get(), size_in_bytes);
       dest->FromInterleaved(
           buffer_.get(), dest->frames(), params_.bits_per_sample() / 8);
     }
 
     return dest->frames();
   }
 
-  virtual void OnError(AudioOutputStream* stream) override {}
+  void OnError(AudioOutputStream* stream) override {}
 
  private:
   // Converts from bytes to milliseconds given number of bytes and existing
   // audio parameters.
   double BytesToMilliseconds(int bytes) const {
     const int frames = bytes / params_.GetBytesPerFrame();
     return (base::TimeDelta::FromMicroseconds(
                 frames * base::Time::kMicrosecondsPerSecond /
                 static_cast<double>(params_.sample_rate()))).InMillisecondsF();
   }
@@ skipping 10 matching lines @@
 
 // Test fixture class for tests which only exercise the output path.
 class AudioAndroidOutputTest : public testing::Test {
  public:
   AudioAndroidOutputTest()
       : loop_(new base::MessageLoopForUI()),
         audio_manager_(AudioManager::CreateForTesting()),
         audio_output_stream_(NULL) {
   }
 
-  virtual ~AudioAndroidOutputTest() {
-  }
+  ~AudioAndroidOutputTest() override {}
 
  protected:
   AudioManager* audio_manager() { return audio_manager_.get(); }
   base::MessageLoopForUI* loop() { return loop_.get(); }
   const AudioParameters& audio_output_parameters() {
     return audio_output_parameters_;
   }
 
   // Synchronously runs the provided callback/closure on the audio thread.
   void RunOnAudioThread(const base::Closure& closure) {
@@ skipping 539 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media