replace OVERRIDE and FINAL with override and final in media/

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/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 160 matching lines @@
     VLOG(0) << "Reading from file: " << file_path.value().c_str();
   }
 
   virtual ~FileAudioSource() {}
 
   // 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 {
+                         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 {}
+  virtual 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 38 matching lines @@
       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 {
+                      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 {}
+  virtual void OnError(AudioInputStream* stream) override {}
 
  private:
   base::WaitableEvent* event_;
   AudioParameters params_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   FILE* binary_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FileAudioSink);
 };
 
@@ skipping 13 matching lines @@
     fifo_.reset(new media::SeekableBuffer(0, 2 * params.GetBytesPerBuffer()));
     buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
   }
 
   virtual ~FullDuplexAudioSinkSource() {}
 
   // AudioInputStream::AudioInputCallback implementation
   virtual void OnData(AudioInputStream* stream,
                       const AudioBus* src,
                       uint32 hardware_delay_bytes,
-                      double volume) OVERRIDE {
+                      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 {}
+  virtual void OnError(AudioInputStream* stream) override {}
 
   // AudioOutputStream::AudioSourceCallback implementation
   virtual int OnMoreData(AudioBus* dest,
-                         uint32 total_bytes_delay) OVERRIDE {
+                         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 {}
+  virtual 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 571 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media