Standardize usage of virtual/override/final specifiers.

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 28 matching lines @@
 
 // Waits till |window| is minimized.
 class MinimizeWaiter : public X11PropertyChangeWaiter {
  public:
   explicit MinimizeWaiter(XID window)
       : X11PropertyChangeWaiter(window, "_NET_WM_STATE") {
     const char* kAtomsToCache[] = { "_NET_WM_STATE_HIDDEN", NULL };
     atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
   }
 
-  virtual ~MinimizeWaiter() {
-  }
+  ~MinimizeWaiter() override {}
 
  private:
   // X11PropertyChangeWaiter:
-  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
+  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;
   }
 
   scoped_ptr<ui::X11AtomCache> atom_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(MinimizeWaiter);
 };
 
 // Waits till |_NET_CLIENT_LIST_STACKING| is updated to include
 // |expected_windows|.
 class StackingClientListWaiter : public X11PropertyChangeWaiter {
  public:
   StackingClientListWaiter(XID* expected_windows, size_t count)
       : X11PropertyChangeWaiter(ui::GetX11RootWindow(),
                                 "_NET_CLIENT_LIST_STACKING"),
         expected_windows_(expected_windows, expected_windows + count) {
   }
 
-  virtual ~StackingClientListWaiter() {
-  }
+  ~StackingClientListWaiter() override {}
 
   // X11PropertyChangeWaiter:
-  virtual void Wait() override {
+  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 {
+  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;
   }
 
   std::vector<XID> expected_windows_;
 
   DISALLOW_COPY_AND_ASSIGN(StackingClientListWaiter);
 };
 
 }  // namespace
 
 class X11TopmostWindowFinderTest : public ViewsTestBase {
  public:
   X11TopmostWindowFinderTest() {
   }
 
-  virtual ~X11TopmostWindowFinderTest() {
-  }
+  ~X11TopmostWindowFinderTest() override {}
 
   // Creates and shows a Widget with |bounds|. The caller takes ownership of
   // the returned widget.
   scoped_ptr<Widget> CreateAndShowWidget(const gfx::Rect& bounds) {
     scoped_ptr<Widget> toplevel(new Widget);
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.native_widget = new DesktopNativeWidgetAura(toplevel.get());
     params.bounds = bounds;
     params.remove_standard_frame = true;
@@ skipping 66 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 {
+  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 {
+  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