replace OVERRIDE and FINAL with override and final in ui/

ui/views/widget/desktop_aura/desktop_screen_x11_unittest.cc

 // Copyright (c) 2013 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/views/widget/desktop_aura/desktop_screen_x11.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
@@ skipping 16 matching lines @@
   explicit TestDesktopNativeWidgetAura(
       views::internal::NativeWidgetDelegate* delegate)
       : views::DesktopNativeWidgetAura(delegate) {}
   virtual ~TestDesktopNativeWidgetAura() {}
 
   void set_window_component(int window_component) {
     window_component_ = window_component;
   }
 
   // DesktopNativeWidgetAura:
-  virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
+  virtual int GetNonClientComponent(const gfx::Point& point) const override {
     return window_component_;
   }
 
  private:
   int window_component_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDesktopNativeWidgetAura);
 };
 
 }  // namespace
 
 namespace views {
 
 const int64 kFirstDisplay = 5321829;
 const int64 kSecondDisplay = 928310;
 
 class DesktopScreenX11Test : public views::ViewsTestBase,
                              public gfx::DisplayObserver {
  public:
   DesktopScreenX11Test() {}
   virtual ~DesktopScreenX11Test() {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ViewsTestBase::SetUp();
     // Initialize the world to the single monitor case.
     std::vector<gfx::Display> displays;
     displays.push_back(gfx::Display(kFirstDisplay, gfx::Rect(0, 0, 640, 480)));
     screen_.reset(new DesktopScreenX11(displays));
     screen_->AddObserver(this);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     screen_.reset();
     ViewsTestBase::TearDown();
   }
 
  protected:
   std::vector<gfx::Display> changed_display_;
   std::vector<gfx::Display> added_display_;
   std::vector<gfx::Display> removed_display_;
 
   DesktopScreenX11* screen() { return screen_.get(); }
@@ skipping 23 matching lines @@
           new views::DesktopNativeWidgetAura(toplevel);
     }
     toplevel_params.bounds = bounds;
     toplevel_params.remove_standard_frame = true;
     toplevel->Init(toplevel_params);
     return toplevel;
   }
 
  private:
   // Overridden from gfx::DisplayObserver:
-  virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE {
+  virtual void OnDisplayAdded(const gfx::Display& new_display) override {
     added_display_.push_back(new_display);
   }
 
-  virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE {
+  virtual void OnDisplayRemoved(const gfx::Display& old_display) override {
     removed_display_.push_back(old_display);
   }
 
   virtual void OnDisplayMetricsChanged(const gfx::Display& display,
-                                       uint32_t metrics) OVERRIDE {
+                                       uint32_t metrics) override {
     changed_display_.push_back(display);
   }
 
   scoped_ptr<DesktopScreenX11> screen_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopScreenX11Test);
 };
 
 TEST_F(DesktopScreenX11Test, BoundsChangeSingleMonitor) {
   std::vector<gfx::Display> displays;
@@ skipping 310 matching lines @@
   NotifyDisplaysChanged(displays);
   EXPECT_EQ(2u, changed_display_.size());
 
   displays[0].set_device_scale_factor(1.f);
   displays[1].set_device_scale_factor(1.f);
   NotifyDisplaysChanged(displays);
   EXPECT_EQ(4u, changed_display_.size());
 }
 
 }  // namespace views