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

ui/display/chromeos/display_configurator_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/display/chromeos/display_configurator.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
 #include "ui/display/chromeos/test/test_display_snapshot.h"
 #include "ui/display/chromeos/test/test_native_display_delegate.h"
 
 namespace ui {
 namespace test {
 
 namespace {
 
 class TestObserver : public DisplayConfigurator::Observer {
  public:
   explicit TestObserver(DisplayConfigurator* configurator)
       : configurator_(configurator) {
     Reset();
     configurator_->AddObserver(this);
   }
-  virtual ~TestObserver() { configurator_->RemoveObserver(this); }
+  ~TestObserver() override { configurator_->RemoveObserver(this); }
 
   int num_changes() const { return num_changes_; }
   int num_failures() const { return num_failures_; }
   const DisplayConfigurator::DisplayStateList& latest_outputs() const {
     return latest_outputs_;
   }
   MultipleDisplayState latest_failed_state() const {
     return latest_failed_state_;
   }
 
   void Reset() {
     num_changes_ = 0;
     num_failures_ = 0;
     latest_outputs_.clear();
     latest_failed_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
   }
 
   // DisplayConfigurator::Observer overrides:
-  virtual void OnDisplayModeChanged(
+  void OnDisplayModeChanged(
       const DisplayConfigurator::DisplayStateList& outputs) override {
     num_changes_++;
     latest_outputs_ = outputs;
   }
 
-  virtual void OnDisplayModeChangeFailed(MultipleDisplayState failed_new_state)
-      override {
+  void OnDisplayModeChangeFailed(
+      MultipleDisplayState failed_new_state) override {
     num_failures_++;
     latest_failed_state_ = failed_new_state;
   }
 
  private:
   DisplayConfigurator* configurator_;  // Not owned.
 
   // Number of times that OnDisplayMode*() has been called.
   int num_changes_;
   int num_failures_;
 
   // Parameters most recently passed to OnDisplayMode*().
   DisplayConfigurator::DisplayStateList latest_outputs_;
   MultipleDisplayState latest_failed_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 class TestStateController : public DisplayConfigurator::StateController {
  public:
   TestStateController() : state_(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {}
-  virtual ~TestStateController() {}
+  ~TestStateController() override {}
 
   void set_state(MultipleDisplayState state) { state_ = state; }
 
   // DisplayConfigurator::StateController overrides:
-  virtual MultipleDisplayState GetStateForDisplayIds(
+  MultipleDisplayState GetStateForDisplayIds(
       const std::vector<int64_t>& outputs) const override {
     return state_;
   }
-  virtual bool GetResolutionForDisplayId(int64_t display_id,
-                                         gfx::Size* size) const override {
+  bool GetResolutionForDisplayId(int64_t display_id,
+                                 gfx::Size* size) const override {
     return false;
   }
 
  private:
   MultipleDisplayState state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStateController);
 };
 
 class TestMirroringController
     : public DisplayConfigurator::SoftwareMirroringController {
  public:
   TestMirroringController() : software_mirroring_enabled_(false) {}
-  virtual ~TestMirroringController() {}
+  ~TestMirroringController() override {}
 
-  virtual void SetSoftwareMirroring(bool enabled) override {
+  void SetSoftwareMirroring(bool enabled) override {
     software_mirroring_enabled_ = enabled;
   }
 
-  virtual bool SoftwareMirroringEnabled() const override {
+  bool SoftwareMirroringEnabled() const override {
     return software_mirroring_enabled_;
   }
 
  private:
   bool software_mirroring_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMirroringController);
 };
 
 class DisplayConfiguratorTest : public testing::Test {
  public:
   DisplayConfiguratorTest()
       : small_mode_(gfx::Size(1366, 768), false, 60.0f),
         big_mode_(gfx::Size(2560, 1600), false, 60.0f),
         observer_(&configurator_),
         test_api_(&configurator_) {}
-  virtual ~DisplayConfiguratorTest() {}
+  ~DisplayConfiguratorTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetDelegateForTesting(
         scoped_ptr<NativeDisplayDelegate>(native_display_delegate_));
 
     configurator_.set_state_controller(&state_controller_);
     configurator_.set_mirroring_controller(&mirroring_controller_);
 
     std::vector<const DisplayMode*> modes;
@@ skipping 1045 matching lines @@
                         GetFramebufferAction(small_mode_.size(), &outputs_[0],
                                              nullptr).c_str(),
                         GetCrtcAction(outputs_[0], &small_mode_,
                                       gfx::Point(0, 0)).c_str(),
                         kUngrab, NULL),
             log_->GetActionsAndClear());
 }
 
 }  // namespace test
 }  // namespace ui