Apply automated fixits for Chrome clang plugin to media.

media/audio/win/audio_low_latency_output_win_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
@@ skipping 63 matching lines @@
     // Reads a test file from media/test/data directory.
     file_ = ReadTestDataFile(name);
 
     // Creates an array that will store delta times between callbacks.
     // The content of this array will be written to a text file at
     // destruction and can then be used for off-line analysis of the exact
     // timing of callbacks. The text file will be stored in media/test/data.
     delta_times_.reset(new int[kMaxDeltaSamples]);
   }
 
-  virtual ~ReadFromFileAudioSource() {
+  ~ReadFromFileAudioSource() override {
     // Get complete file path to output file in directory containing
     // media_unittests.exe.
     base::FilePath file_name;
     EXPECT_TRUE(PathService::Get(base::DIR_EXE, &file_name));
     file_name = file_name.AppendASCII(kDeltaTimeMsFileName);
 
     EXPECT_TRUE(!text_file_);
     text_file_ = base::OpenFile(file_name, "wt");
     DLOG_IF(ERROR, !text_file_) << "Failed to open log file.";
 
     // Write the array which contains delta times to a text file.
     size_t elements_written = 0;
     while (elements_written < elements_to_write_) {
       fprintf(text_file_, "%d\n", delta_times_[elements_written]);
       ++elements_written;
     }
 
     base::CloseFile(text_file_);
   }
 
   // AudioOutputStream::AudioSourceCallback implementation.
-  virtual int OnMoreData(AudioBus* audio_bus,
-                         uint32 total_bytes_delay) {
+  int OnMoreData(AudioBus* audio_bus, uint32 total_bytes_delay) override {
     // Store time difference between two successive callbacks in an array.
     // These values will be written to a file in the destructor.
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_call_time_).InMilliseconds();
     previous_call_time_ = now_time;
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
     int max_size =
         audio_bus->frames() * audio_bus->channels() * kBitsPerSample / 8;
 
     // Use samples read from a data file and fill up the audio buffer
     // provided to us in the callback.
     if (pos_ + static_cast<int>(max_size) > file_size())
       max_size = file_size() - pos_;
     int frames = max_size / (audio_bus->channels() * kBitsPerSample / 8);
     if (max_size) {
       audio_bus->FromInterleaved(
           file_->data() + pos_, frames, kBitsPerSample / 8);
       pos_ += max_size;
     }
     return frames;
   }
 
-  virtual void OnError(AudioOutputStream* stream) {}
+  void OnError(AudioOutputStream* stream) override {}
 
   int file_size() { return file_->data_size(); }
 
  private:
   scoped_refptr<DecoderBuffer> file_;
   scoped_ptr<int[]> delta_times_;
   int pos_;
   base::TimeTicks previous_call_time_;
   FILE* text_file_;
   size_t elements_to_write_;
@@ skipping 469 matching lines @@
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(),
                         TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 }  // namespace media