Standardize usage of virtual/override/final specifiers.

components/copresence/mediums/audio/audio_manager_unittest.cc

 // Copyright 2014 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 "components/copresence/mediums/audio/audio_manager.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "components/copresence/mediums/audio/audio_manager_impl.h"
 #include "components/copresence/mediums/audio/audio_player.h"
 #include "components/copresence/mediums/audio/audio_recorder.h"
 #include "components/copresence/test/audio_test_support.h"
 #include "media/base/audio_bus.h"
 //#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace copresence {
 
 class AudioPlayerStub final : public AudioPlayer {
  public:
   AudioPlayerStub() : is_playing_(false) {}
-  virtual ~AudioPlayerStub() {}
+  ~AudioPlayerStub() override {}
 
   // AudioPlayer overrides:
   void Initialize() override {}
   void Play(const scoped_refptr<media::AudioBusRefCounted>&) override {
     is_playing_ = true;
   }
   void Stop() override { is_playing_ = false; }
   void Finalize() override { delete this; }
   bool IsPlaying() override { return is_playing_; }
 
  private:
   bool is_playing_;
   DISALLOW_COPY_AND_ASSIGN(AudioPlayerStub);
 };
 
 class AudioRecorderStub final : public AudioRecorder {
  public:
   AudioRecorderStub() : is_recording_(false) {}
-  virtual ~AudioRecorderStub() {}
+  ~AudioRecorderStub() override {}
 
   // AudioRecorder overrides:
   void Initialize(const RecordedSamplesCallback& cb) override { cb_ = cb; }
   void Record() override { is_recording_ = true; }
   void Stop() override { is_recording_ = false; }
   void Finalize() override { delete this; }
   bool IsRecording() override { return is_recording_; }
 
   void TriggerDecodeRequest() {
     if (!cb_.is_null())
@@ skipping 15 matching lines @@
         inaudible_player_(new AudioPlayerStub),
         recorder_(new AudioRecorderStub),
         last_received_decode_type_(AUDIO_TYPE_UNKNOWN) {
     audio_manager_->set_player_for_testing(AUDIBLE, audible_player_);
     audio_manager_->set_player_for_testing(INAUDIBLE, inaudible_player_);
     audio_manager_->set_recorder_for_testing(recorder_);
     audio_manager_->Initialize(
         base::Bind(&AudioManagerTest::DecodeSamples, base::Unretained(this)),
         base::Bind(&AudioManagerTest::EncodeToken, base::Unretained(this)));
   }
-  virtual ~AudioManagerTest() {}
+  ~AudioManagerTest() override {}
 
  protected:
   void EncodeToken(const std::string& token,
                    AudioType audible,
                    const AudioManager::SamplesCallback& callback) {
     callback.Run(
         token, audible, CreateRandomAudioRefCounted(0x1337, 1, 0x7331));
   }
 
   void DecodeSamples(AudioType type, const std::string& /* samples */) {
@@ skipping 54 matching lines @@
   audio_manager_->StartRecording(INAUDIBLE);
   recorder_->TriggerDecodeRequest();
   EXPECT_EQ(BOTH, last_received_decode_type_);
 
   audio_manager_->StopRecording(AUDIBLE);
   recorder_->TriggerDecodeRequest();
   EXPECT_EQ(INAUDIBLE, last_received_decode_type_);
 }
 
 }  // namespace copresence