Standardize usage of virtual/override/final specifiers.

ui/views/widget/desktop_aura/desktop_window_tree_host_x11_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 <vector>
 
 #include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
 
 // Get rid of X11 macros which conflict with gtest.
@@ skipping 31 matching lines @@
         hint_(hint),
         wait_till_set_(wait_till_set) {
 
     const char* kAtomsToCache[] = {
         hint,
         NULL
     };
     atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
   }
 
-  virtual ~WMStateWaiter() {
-  }
+  ~WMStateWaiter() override {}
 
  private:
   // X11PropertyChangeWaiter:
-  virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
+  bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<Atom> hints;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &hints)) {
       std::vector<Atom>::iterator it = std::find(
           hints.begin(),
           hints.end(),
           atom_cache_->GetAtom(hint_));
       bool hint_set = (it != hints.end());
       return hint_set != wait_till_set_;
     }
     return true;
   }
 
   scoped_ptr<ui::X11AtomCache> atom_cache_;
 
   // The name of the hint to wait to get set or unset.
   const char* hint_;
 
   // Whether we are waiting for |hint| to be set or unset.
   bool wait_till_set_;
 
   DISALLOW_COPY_AND_ASSIGN(WMStateWaiter);
 };
 
 // A NonClientFrameView with a window mask with the bottom right corner cut out.
 class ShapedNonClientFrameView : public NonClientFrameView {
  public:
   explicit ShapedNonClientFrameView() {
   }
 
-  virtual ~ShapedNonClientFrameView() {
-  }
+  ~ShapedNonClientFrameView() override {}
 
   // NonClientFrameView:
-  virtual gfx::Rect GetBoundsForClientView() const override {
-    return bounds();
-  }
-  virtual gfx::Rect GetWindowBoundsForClientBounds(
+  gfx::Rect GetBoundsForClientView() const override { return bounds(); }
+  gfx::Rect GetWindowBoundsForClientBounds(
       const gfx::Rect& client_bounds) const override {
     return client_bounds;
   }
-  virtual int NonClientHitTest(const gfx::Point& point) override {
-    return HTNOWHERE;
-  }
-  virtual void GetWindowMask(const gfx::Size& size,
-                             gfx::Path* window_mask) override {
+  int NonClientHitTest(const gfx::Point& point) override { return HTNOWHERE; }
+  void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask) override {
     int right = size.width();
     int bottom = size.height();
 
     window_mask->moveTo(0, 0);
     window_mask->lineTo(0, bottom);
     window_mask->lineTo(right, bottom);
     window_mask->lineTo(right, 10);
     window_mask->lineTo(right - 10, 10);
     window_mask->lineTo(right - 10, 0);
     window_mask->close();
   }
-  virtual void ResetWindowControls() override {
-  }
-  virtual void UpdateWindowIcon() override {
-  }
-  virtual void UpdateWindowTitle() override {
-  }
-  virtual void SizeConstraintsChanged() override {
-  }
+  void ResetWindowControls() override {}
+  void UpdateWindowIcon() override {}
+  void UpdateWindowTitle() override {}
+  void SizeConstraintsChanged() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShapedNonClientFrameView);
 };
 
 class ShapedWidgetDelegate : public WidgetDelegateView {
  public:
   ShapedWidgetDelegate() {
   }
 
-  virtual ~ShapedWidgetDelegate() {
-  }
+  ~ShapedWidgetDelegate() override {}
 
   // WidgetDelegateView:
-  virtual NonClientFrameView* CreateNonClientFrameView(
-      Widget* widget) override {
+  NonClientFrameView* CreateNonClientFrameView(Widget* widget) override {
     return new ShapedNonClientFrameView;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShapedWidgetDelegate);
 };
 
 // Creates a widget of size 100x100.
 scoped_ptr<Widget> CreateWidget(WidgetDelegate* delegate) {
   scoped_ptr<Widget> widget(new Widget);
@@ skipping 47 matching lines @@
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
 }  // namespace
 
 class DesktopWindowTreeHostX11Test : public ViewsTestBase {
  public:
   DesktopWindowTreeHostX11Test() {
   }
-  virtual ~DesktopWindowTreeHostX11Test() {
-  }
+  ~DesktopWindowTreeHostX11Test() override {}
 
-  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(gfx::GetXDisplay(), True);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     XSynchronize(gfx::GetXDisplay(), False);
     ViewsTestBase::TearDown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DesktopWindowTreeHostX11Test);
 };
 
 // Tests that the shape is properly set on the x window.
 TEST_F(DesktopWindowTreeHostX11Test, Shape) {
@@ skipping 235 matching lines @@
         SubstructureRedirectMask | SubstructureNotifyMask,
         &xevent);
 
     WMStateWaiter waiter(xid, "_NET_WM_STATE_FOCUSED", true);
     waiter.Wait();
   }
   EXPECT_TRUE(widget.GetNativeWindow()->IsVisible());
 }
 
 }  // namespace views