replace OVERRIDE and FINAL with override and final 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 <stdint.h>
 
 #include <cmath>
 #include <cstdarg>
@@ skipping 136 matching lines @@
     outputs_ = outputs;
   }
 
   void set_max_configurable_pixels(int pixels) {
     max_configurable_pixels_ = pixels;
   }
 
   void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
 
   // DisplayConfigurator::Delegate overrides:
-  virtual void Initialize() OVERRIDE { log_->AppendAction(kInitXRandR); }
-  virtual void GrabServer() OVERRIDE { log_->AppendAction(kGrab); }
-  virtual void UngrabServer() OVERRIDE { log_->AppendAction(kUngrab); }
-  virtual void SyncWithServer() OVERRIDE { log_->AppendAction(kSync); }
-  virtual void SetBackgroundColor(uint32_t color_argb) OVERRIDE {
+  virtual void Initialize() override { log_->AppendAction(kInitXRandR); }
+  virtual void GrabServer() override { log_->AppendAction(kGrab); }
+  virtual void UngrabServer() override { log_->AppendAction(kUngrab); }
+  virtual void SyncWithServer() override { log_->AppendAction(kSync); }
+  virtual void SetBackgroundColor(uint32_t color_argb) override {
     log_->AppendAction(GetBackgroundAction(color_argb));
   }
-  virtual void ForceDPMSOn() OVERRIDE { log_->AppendAction(kForceDPMS); }
-  virtual std::vector<DisplaySnapshot*> GetDisplays() OVERRIDE {
+  virtual void ForceDPMSOn() override { log_->AppendAction(kForceDPMS); }
+  virtual std::vector<DisplaySnapshot*> GetDisplays() override {
     return outputs_;
   }
   virtual void AddMode(const DisplaySnapshot& output,
-                       const DisplayMode* mode) OVERRIDE {
+                       const DisplayMode* mode) override {
     log_->AppendAction(GetAddOutputModeAction(output, mode));
   }
   virtual bool Configure(const DisplaySnapshot& output,
                          const DisplayMode* mode,
-                         const gfx::Point& origin) OVERRIDE {
+                         const gfx::Point& origin) override {
     log_->AppendAction(GetCrtcAction(output, mode, origin));
 
     if (max_configurable_pixels_ == 0)
       return true;
 
     if (!mode)
       return false;
 
     return mode->size().GetArea() <= max_configurable_pixels_;
   }
-  virtual void CreateFrameBuffer(const gfx::Size& size) OVERRIDE {
+  virtual void CreateFrameBuffer(const gfx::Size& size) override {
     log_->AppendAction(
         GetFramebufferAction(size,
                              outputs_.size() >= 1 ? outputs_[0] : NULL,
                              outputs_.size() >= 2 ? outputs_[1] : NULL));
   }
   virtual bool GetHDCPState(const DisplaySnapshot& output,
-                            HDCPState* state) OVERRIDE {
+                            HDCPState* state) override {
     *state = hdcp_state_;
     return true;
   }
 
   virtual bool SetHDCPState(const DisplaySnapshot& output,
-                            HDCPState state) OVERRIDE {
+                            HDCPState state) override {
     log_->AppendAction(GetSetHDCPStateAction(output, state));
     return true;
   }
 
   virtual std::vector<ui::ColorCalibrationProfile>
-  GetAvailableColorCalibrationProfiles(const DisplaySnapshot& output) OVERRIDE {
+  GetAvailableColorCalibrationProfiles(const DisplaySnapshot& output) override {
     return std::vector<ui::ColorCalibrationProfile>();
   }
 
   virtual bool SetColorCalibrationProfile(
       const DisplaySnapshot& output,
-      ui::ColorCalibrationProfile new_profile) OVERRIDE {
+      ui::ColorCalibrationProfile new_profile) override {
     return false;
   }
 
-  virtual void AddObserver(NativeDisplayObserver* observer) OVERRIDE {}
+  virtual void AddObserver(NativeDisplayObserver* observer) override {}
 
-  virtual void RemoveObserver(NativeDisplayObserver* observer) OVERRIDE {}
+  virtual void RemoveObserver(NativeDisplayObserver* observer) override {}
 
  private:
   // Outputs to be returned by GetDisplays().
   std::vector<DisplaySnapshot*> outputs_;
 
   // |max_configurable_pixels_| represents the maximum number of pixels that
   // Configure will support.  Tests can use this to force Configure
   // to fail if attempting to set a resolution that is higher than what
   // a device might support under a given circumstance.
   // A value of 0 means that no limit is enforced and Configure will
@@ skipping 28 matching lines @@
 
   void Reset() {
     num_changes_ = 0;
     num_failures_ = 0;
     latest_outputs_.clear();
     latest_failed_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
   }
 
   // DisplayConfigurator::Observer overrides:
   virtual void OnDisplayModeChanged(
-      const DisplayConfigurator::DisplayStateList& outputs) OVERRIDE {
+      const DisplayConfigurator::DisplayStateList& outputs) override {
     num_changes_++;
     latest_outputs_ = outputs;
   }
 
   virtual void OnDisplayModeChangeFailed(MultipleDisplayState failed_new_state)
-      OVERRIDE {
+      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() {}
 
   void set_state(MultipleDisplayState state) { state_ = state; }
 
   // DisplayConfigurator::StateController overrides:
   virtual MultipleDisplayState GetStateForDisplayIds(
-      const std::vector<int64_t>& outputs) const OVERRIDE {
+      const std::vector<int64_t>& outputs) const override {
     return state_;
   }
   virtual bool GetResolutionForDisplayId(int64_t display_id,
-                                         gfx::Size* size) const OVERRIDE {
+                                         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() {}
 
-  virtual void SetSoftwareMirroring(bool enabled) OVERRIDE {
+  virtual void SetSoftwareMirroring(bool enabled) override {
     software_mirroring_enabled_ = enabled;
   }
 
-  virtual bool SoftwareMirroringEnabled() const OVERRIDE {
+  virtual 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() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual 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 979 matching lines @@
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
 }  // namespace ui