Update {virtual,override,final} to follow C++11 style chrome/browser/ui.

chrome/browser/ui/ash/volume_controller_browsertest_chromeos.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 <vector>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/ui/ash/volume_controller_chromeos.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chromeos/audio/chromeos_sounds.h"
 #include "chromeos/audio/cras_audio_handler.h"
 #include "chromeos/chromeos_switches.h"
 #include "media/audio/sounds/sounds_manager.h"
 #include "ui/base/accelerators/accelerator.h"
 
 namespace {
 
 class SoundsManagerTestImpl : public media::SoundsManager {
  public:
   SoundsManagerTestImpl()
     : is_sound_initialized_(chromeos::SOUND_COUNT),
       num_play_requests_(chromeos::SOUND_COUNT) {
   }
 
-  virtual ~SoundsManagerTestImpl() {}
+  ~SoundsManagerTestImpl() override {}
 
-  virtual bool Initialize(SoundKey key,
-                          const base::StringPiece& /* data */) override {
+  bool Initialize(SoundKey key, const base::StringPiece& /* data */) override {
     is_sound_initialized_[key] = true;
     return true;
   }
 
-  virtual bool Play(SoundKey key) override {
+  bool Play(SoundKey key) override {
     ++num_play_requests_[key];
     return true;
   }
 
-  virtual base::TimeDelta GetDuration(SoundKey /* key */) override {
+  base::TimeDelta GetDuration(SoundKey /* key */) override {
     return base::TimeDelta();
   }
 
   bool is_sound_initialized(SoundKey key) const {
     return is_sound_initialized_[key];
   }
 
   int num_play_requests(SoundKey key) const {
     return num_play_requests_[key];
   }
 
  private:
   std::vector<bool> is_sound_initialized_;
   std::vector<int> num_play_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(SoundsManagerTestImpl);
 };
 
 class VolumeControllerTest : public InProcessBrowserTest {
  public:
   VolumeControllerTest() {}
-  virtual ~VolumeControllerTest() {}
+  ~VolumeControllerTest() override {}
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     volume_controller_.reset(new VolumeController());
     audio_handler_ = chromeos::CrasAudioHandler::Get();
   }
 
  protected:
   void VolumeMute() {
     volume_controller_->HandleVolumeMute(ui::Accelerator());
   }
 
   void VolumeUp() {
@@ skipping 76 matching lines @@
   // Thus, further VolumeUp doesn't recover the volume, it's just slightly
   // bigger than 0.
   VolumeUp();
   EXPECT_LT(0, audio_handler_->GetOutputVolumePercent());
   EXPECT_GT(initial_volume, audio_handler_->GetOutputVolumePercent());
 }
 
 class VolumeControllerSoundsTest : public VolumeControllerTest {
  public:
   VolumeControllerSoundsTest() : sounds_manager_(NULL) {}
-  virtual ~VolumeControllerSoundsTest() {}
+  ~VolumeControllerSoundsTest() override {}
 
-  virtual void SetUpInProcessBrowserTestFixture() override {
+  void SetUpInProcessBrowserTestFixture() override {
     sounds_manager_ = new SoundsManagerTestImpl();
     media::SoundsManager::InitializeForTesting(sounds_manager_);
   }
 
   void EnableSpokenFeedback(bool enabled) {
     chromeos::AccessibilityManager* manager =
         chromeos::AccessibilityManager::Get();
     manager->EnableSpokenFeedback(enabled, ui::A11Y_NOTIFICATION_NONE);
   }
 
@@ skipping 53 matching lines @@
 
   // Check that audio is unmuted and sound is played.
   VolumeUp();
   ASSERT_FALSE(audio_handler_->IsOutputMuted());
   EXPECT_EQ(4, num_play_requests());
 }
 
 class VolumeControllerSoundsDisabledTest : public VolumeControllerSoundsTest {
  public:
   VolumeControllerSoundsDisabledTest() {}
-  virtual ~VolumeControllerSoundsDisabledTest() {}
+  ~VolumeControllerSoundsDisabledTest() override {}
 
-  virtual void SetUpCommandLine(base::CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     VolumeControllerSoundsTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(chromeos::switches::kDisableVolumeAdjustSound);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VolumeControllerSoundsDisabledTest);
 };
 
 IN_PROC_BROWSER_TEST_F(VolumeControllerSoundsDisabledTest,
                        VolumeAdjustSounds) {
   EXPECT_FALSE(is_sound_initialized());
 
   // Check that sound isn't played on volume up and volume down.
   audio_handler_->SetOutputVolumePercent(50);
   VolumeUp();
   VolumeDown();
   EXPECT_EQ(0, num_play_requests());
 }
 
 }  // namespace