Standardize usage of virtual/override/final specifiers.

media/audio/audio_low_latency_input_output_unittest.cc

 // Copyright (c) 2012 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/basictypes.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/synchronization/lock.h"
@@ skipping 75 matching lines @@
   // Reported render/output delay. Typical value is ~40 [ms].
   int output_delay_ms;
 };
 
 // This class mocks the platform specific audio manager and overrides
 // the GetMessageLoop() method to ensure that we can run our tests on
 // the main thread instead of the audio thread.
 class MockAudioManager : public AudioManagerAnyPlatform {
  public:
   MockAudioManager() : AudioManagerAnyPlatform(&fake_audio_log_factory_) {}
-  virtual ~MockAudioManager() {}
+  ~MockAudioManager() override {}
 
-  virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override {
+  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override {
     return base::MessageLoop::current()->message_loop_proxy();
   }
 
  private:
   FakeAudioLogFactory fake_audio_log_factory_;
   DISALLOW_COPY_AND_ASSIGN(MockAudioManager);
 };
 
 // Test fixture class.
 class AudioLowLatencyInputOutputTest : public testing::Test {
  protected:
   AudioLowLatencyInputOutputTest() {}
 
-  virtual ~AudioLowLatencyInputOutputTest() {}
+  ~AudioLowLatencyInputOutputTest() override {}
 
   AudioManager* audio_manager() { return &mock_audio_manager_; }
   base::MessageLoopForUI* message_loop() { return &message_loop_; }
 
   // Convenience method which ensures that we are not running on the build
   // bots and that at least one valid input and output device can be found.
   bool CanRunAudioTests() {
     bool input = audio_manager()->HasAudioInputDevices();
     bool output = audio_manager()->HasAudioOutputDevices();
     LOG_IF(WARNING, !input) << "No input device detected.";
@@ skipping 32 matching lines @@
 
     // Start with the smallest possible buffer size. It will be increased
     // dynamically during the test if required.
     buffer_.reset(
         new media::SeekableBuffer(0, samples_per_packet_ * frame_size_));
 
     frames_to_ms_ = static_cast<double>(1000.0 / sample_rate_);
     delay_states_.reset(new AudioDelayState[kMaxDelayMeasurements]);
   }
 
-  virtual ~FullDuplexAudioSinkSource() {
+  ~FullDuplexAudioSinkSource() override {
     // Get complete file path to output file in the directory containing
     // media_unittests.exe. Example: src/build/Debug/audio_delay_values_ms.txt.
     base::FilePath file_name;
     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_name));
     file_name = file_name.AppendASCII(kDelayValuesFileName);
 
     FILE* text_file = base::OpenFile(file_name, "wt");
     DLOG_IF(ERROR, !text_file) << "Failed to open log file.";
     VLOG(0) << ">> Output file " << file_name.value() << " has been created.";
 
     // Write the array which contains time-stamps, buffer size and
     // audio delays values to a text file.
     size_t elements_written = 0;
     while (elements_written <
         std::min(input_elements_to_write_, output_elements_to_write_)) {
       const AudioDelayState state = delay_states_[elements_written];
       fprintf(text_file, "%d %d %d %d\n",
               state.delta_time_ms,
               state.buffer_delay_ms,
               state.input_delay_ms,
               state.output_delay_ms);
       ++elements_written;
     }
 
     base::CloseFile(text_file);
   }
 
   // AudioInputStream::AudioInputCallback.
-  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 {
     base::AutoLock lock(lock_);
 
     // Update three components in the AudioDelayState for this recorded
     // audio packet.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_write_time_).InMilliseconds();
     previous_write_time_ = now_time;
     if (input_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[input_elements_to_write_].delta_time_ms = diff;
       delay_states_[input_elements_to_write_].buffer_delay_ms =
           BytesToMilliseconds(buffer_->forward_bytes());
       delay_states_[input_elements_to_write_].input_delay_ms =
           BytesToMilliseconds(hardware_delay_bytes);
       ++input_elements_to_write_;
     }
 
     // TODO(henrika): fix this and use AudioFifo instead.
     // Store the captured audio packet in a seekable media buffer.
     // if (!buffer_->Append(src, size)) {
     // An attempt to write outside the buffer limits has been made.
     // Double the buffer capacity to ensure that we have a buffer large
     // enough to handle the current sample test scenario.
     //   buffer_->set_forward_capacity(2 * buffer_->forward_capacity());
     //   buffer_->Clear();
     // }
   }
 
-  virtual void OnError(AudioInputStream* stream) override {}
+  void OnError(AudioInputStream* stream) override {}
 
   // AudioOutputStream::AudioSourceCallback.
-  virtual int OnMoreData(AudioBus* audio_bus,
-                         uint32 total_bytes_delay) override {
+  int OnMoreData(AudioBus* audio_bus, uint32 total_bytes_delay) override {
     base::AutoLock lock(lock_);
 
     // Update one component in the AudioDelayState for the packet
     // which is about to be played out.
     if (output_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[output_elements_to_write_].output_delay_ms =
           BytesToMilliseconds(total_bytes_delay);
       ++output_elements_to_write_;
     }
 
     int size;
     const uint8* source;
     // Read the data from the seekable media buffer which contains
     // captured data at the same size and sample rate as the output side.
     if (buffer_->GetCurrentChunk(&source, &size) && size > 0) {
       EXPECT_EQ(channels_, audio_bus->channels());
       size = std::min(audio_bus->frames() * frame_size_, size);
       EXPECT_EQ(static_cast<size_t>(size) % sizeof(*audio_bus->channel(0)), 0U);
       audio_bus->FromInterleaved(
           source, size / frame_size_, frame_size_ / channels_);
       buffer_->Seek(size);
       return size / frame_size_;
     }
 
     return 0;
   }
 
-  virtual void OnError(AudioOutputStream* stream) override {}
+  void OnError(AudioOutputStream* stream) override {}
 
  protected:
   // Converts from bytes to milliseconds taking the sample rate and size
   // of an audio frame into account.
   int BytesToMilliseconds(uint32 delay_bytes) const {
     return static_cast<int>((delay_bytes / frame_size_) * frames_to_ms_ + 0.5);
   }
 
  private:
   base::Lock lock_;
@@ skipping 169 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunUntilIdle() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media