replace OVERRIDE and FINAL with override and final in ui/

ui/views/widget/desktop_aura/x11_topmost_window_finder_interactive_uitest.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/views/widget/desktop_aura/x11_topmost_window_finder.h"
 
 #include <algorithm>
 #include <vector>
 #include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
@@ skipping 33 matching lines @@
       : X11PropertyChangeWaiter(window, "_NET_WM_STATE") {
     const char* kAtomsToCache[] = { "_NET_WM_STATE_HIDDEN", NULL };
     atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
   }
 
   virtual ~MinimizeWaiter() {
   }
 
  private:
   // X11PropertyChangeWaiter:
-  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) OVERRIDE {
+  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<Atom> wm_states;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &wm_states)) {
       std::vector<Atom>::iterator it = std::find(
           wm_states.begin(),
           wm_states.end(),
           atom_cache_->GetAtom("_NET_WM_STATE_HIDDEN"));
       return it == wm_states.end();
     }
     return true;
   }
@@ skipping 10 matching lines @@
   StackingClientListWaiter(XID* expected_windows, size_t count)
       : X11PropertyChangeWaiter(ui::GetX11RootWindow(),
                                 "_NET_CLIENT_LIST_STACKING"),
         expected_windows_(expected_windows, expected_windows + count) {
   }
 
   virtual ~StackingClientListWaiter() {
   }
 
   // X11PropertyChangeWaiter:
-  virtual void Wait() OVERRIDE {
+  virtual void Wait() override {
     // StackingClientListWaiter may be created after
     // _NET_CLIENT_LIST_STACKING already contains |expected_windows|.
     if (!ShouldKeepOnWaiting(NULL))
       return;
 
     X11PropertyChangeWaiter::Wait();
   }
 
  private:
   // X11PropertyChangeWaiter:
-  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) OVERRIDE {
+  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<XID> stack;
     ui::GetXWindowStack(ui::GetX11RootWindow(), &stack);
     for (size_t i = 0; i < expected_windows_.size(); ++i) {
       std::vector<XID>::iterator it = std::find(
           stack.begin(), stack.end(), expected_windows_[i]);
       if (it == stack.end())
         return true;
     }
     return false;
   }
@@ skipping 91 matching lines @@
 
   static void SetUpTestCase() {
     gfx::GLSurface::InitializeOneOffForTests();
     ui::RegisterPathProvider();
     base::FilePath ui_test_pak_path;
     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
   }
 
   // ViewsTestBase:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ViewsTestBase::SetUp();
 
     // Make X11 synchronous for our display connection. This does not force the
     // window manager to behave synchronously.
     XSynchronize(xdisplay(), True);
 
     // Ensure that the X11DesktopHandler exists. The X11DesktopHandler is
     // necessary to properly track menu windows.
     X11DesktopHandler::get();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     XSynchronize(xdisplay(), False);
     ViewsTestBase::TearDown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(X11TopmostWindowFinderTest);
 };
 
 TEST_F(X11TopmostWindowFinderTest, Basic) {
   // Avoid positioning test windows at 0x0 because window managers often have a
@@ skipping 206 matching lines @@
 
   EXPECT_EQ(xid, FindTopmostXWindowAt(110, 110));
   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(150, 120));
   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(210, 120));
 
   XDestroyWindow(xdisplay(), xid);
   XDestroyWindow(xdisplay(), menu_xid);
 }
 
 }  // namespace views