Update {virtual,override,final} to follow C++11 style in ui.

ui/chromeos/touch_exploration_controller_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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/test_cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gestures/gesture_provider_aura.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 namespace ui {
 
 namespace {
 
 // Records all mouse, touch, gesture, and key events.
 class EventCapturer : public ui::EventHandler {
  public:
   EventCapturer() {}
-  virtual ~EventCapturer() {}
+  ~EventCapturer() override {}
 
   void Reset() {
     events_.clear();
   }
 
-  virtual void OnEvent(ui::Event* event) override {
+  void OnEvent(ui::Event* event) override {
     if (event->IsMouseEvent()) {
       events_.push_back(
           new ui::MouseEvent(static_cast<ui::MouseEvent&>(*event)));
     } else if (event->IsTouchEvent()) {
       events_.push_back(
           new ui::TouchEvent(static_cast<ui::TouchEvent&>(*event)));
     } else if (event->IsGestureEvent()) {
       events_.push_back(
           new ui::GestureEvent(static_cast<ui::GestureEvent&>(*event)));
     } else if (event->IsKeyEvent()) {
@@ skipping 21 matching lines @@
   if (n <= 0)
     return 0;
   if (n == 1)
     return 1;
   return n * Factorial(n - 1);
 }
 
 class MockTouchExplorationControllerDelegate
     : public ui::TouchExplorationControllerDelegate {
  public:
-  virtual void SetOutputLevel(int volume) override {
+  void SetOutputLevel(int volume) override {
     volume_changes_.push_back(volume);
   }
-  virtual void SilenceSpokenFeedback() override {
-  }
-  virtual void PlayVolumeAdjustEarcon() override {
-    ++num_times_adjust_sound_played_;
-  }
-  virtual void PlayPassthroughEarcon() override {
-    ++num_times_passthrough_played_;
-  }
-  virtual void PlayExitScreenEarcon() override {
-    ++num_times_exit_screen_played_;
-  }
-  virtual void PlayEnterScreenEarcon() override {
-    ++num_times_enter_screen_played_;
-  }
+  void SilenceSpokenFeedback() override {}
+  void PlayVolumeAdjustEarcon() override { ++num_times_adjust_sound_played_; }
+  void PlayPassthroughEarcon() override { ++num_times_passthrough_played_; }
+  void PlayExitScreenEarcon() override { ++num_times_exit_screen_played_; }
+  void PlayEnterScreenEarcon() override { ++num_times_enter_screen_played_; }
 
   const std::vector<float> VolumeChanges() { return volume_changes_; }
   size_t NumAdjustSounds() { return num_times_adjust_sound_played_; }
   size_t NumPassthroughSounds() { return num_times_passthrough_played_; }
   size_t NumExitScreenSounds() { return num_times_exit_screen_played_; }
   size_t NumEnterScreenSounds() {
     return num_times_enter_screen_played_;
   }
 
   void ResetCountersToZero() {
@@ skipping 90 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationControllerTestApi);
 };
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest() : simulated_clock_(new base::SimpleTestTickClock()) {
     // Tests fail if time is ever 0.
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
   }
-  virtual ~TouchExplorationTest() {}
+  ~TouchExplorationTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
       gfx::GLSurface::InitializeOneOffForTests();
     aura::test::AuraTestBase::SetUp();
     cursor_client_.reset(new aura::test::TestCursorClient(root_window()));
     root_window()->AddPreTargetHandler(&event_capturer_);
     generator_.reset(new test::EventGenerator(root_window()));
     // The generator takes ownership of the tick clock.
     generator_->SetTickClock(scoped_ptr<base::TickClock>(simulated_clock_));
     cursor_client()->ShowCursor();
     cursor_client()->DisableMouseEvents();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     root_window()->RemovePreTargetHandler(&event_capturer_);
     SwitchTouchExplorationMode(false);
     cursor_client_.reset();
     aura::test::AuraTestBase::TearDown();
   }
 
  protected:
   aura::client::CursorClient* cursor_client() { return cursor_client_.get(); }
 
   const ScopedVector<ui::Event>& GetCapturedEvents() {
@@ skipping 1713 matching lines @@
     generator_->PressTouch();
     generator_->MoveTouch(initial_press);
     generator_->MoveTouch(*point);
     generator_->ReleaseTouch();
     ASSERT_EQ(1U, delegate_.NumExitScreenSounds());
     delegate_.ResetCountersToZero();
   }
 }
 
 }  // namespace ui