Standardize usage of virtual/override/final specifiers.

ui/views/widget/native_widget_aura_unittest.cc

 // Copyright (c) 2012 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/native_widget_aura.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 19 matching lines @@
   Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = parent;
   widget->Init(params);
   return static_cast<NativeWidgetAura*>(widget->native_widget());
 }
 
 class NativeWidgetAuraTest : public aura::test::AuraTestBase {
  public:
   NativeWidgetAuraTest() {}
-  virtual ~NativeWidgetAuraTest() {}
+  ~NativeWidgetAuraTest() override {}
 
   // testing::Test overrides:
-  virtual void SetUp() override {
+  void SetUp() override {
     AuraTestBase::SetUp();
     new wm::DefaultActivationClient(root_window());
     host()->SetBounds(gfx::Rect(640, 480));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetAuraTest);
 };
 
 TEST_F(NativeWidgetAuraTest, CenterWindowLargeParent) {
@@ skipping 42 matching lines @@
   window->CenterWindow(gfx::Size(500, 600));
 
   // |window| should be no bigger than |parent|.
   EXPECT_EQ("20,40 480x320", window->GetNativeWindow()->bounds().ToString());
   widget->CloseNow();
 }
 
 class TestLayoutManagerBase : public aura::LayoutManager {
  public:
   TestLayoutManagerBase() {}
-  virtual ~TestLayoutManagerBase() {}
+  ~TestLayoutManagerBase() override {}
 
   // aura::LayoutManager:
-  virtual void OnWindowResized() override {}
-  virtual void OnWindowAddedToLayout(aura::Window* child) override {}
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override {}
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visible) override {}
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) override {}
+  void OnWindowResized() override {}
+  void OnWindowAddedToLayout(aura::Window* child) override {}
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
+  void OnWindowRemovedFromLayout(aura::Window* child) override {}
+  void OnChildWindowVisibilityChanged(aura::Window* child,
+                                      bool visible) override {}
+  void SetChildBounds(aura::Window* child,
+                      const gfx::Rect& requested_bounds) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestLayoutManagerBase);
 };
 
 // Used by ShowMaximizedDoesntBounceAround. See it for details.
 class MaximizeLayoutManager : public TestLayoutManagerBase {
  public:
   MaximizeLayoutManager() {}
-  virtual ~MaximizeLayoutManager() {}
+  ~MaximizeLayoutManager() override {}
 
  private:
   // aura::LayoutManager:
-  virtual void OnWindowAddedToLayout(aura::Window* child) override {
+  void OnWindowAddedToLayout(aura::Window* child) override {
     // This simulates what happens when adding a maximized window.
     SetChildBoundsDirect(child, gfx::Rect(0, 0, 300, 300));
   }
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeLayoutManager);
 };
 
 // This simulates BrowserView, which creates a custom RootView so that
 // OnNativeWidgetSizeChanged that is invoked during Init matters.
 class TestWidget : public views::Widget {
  public:
   TestWidget() : did_size_change_more_than_once_(false) {
   }
 
   // Returns true if the size changes to a non-empty size, and then to another
   // size.
   bool did_size_change_more_than_once() const {
     return did_size_change_more_than_once_;
   }
 
-  virtual void OnNativeWidgetSizeChanged(const gfx::Size& new_size) override {
+  void OnNativeWidgetSizeChanged(const gfx::Size& new_size) override {
     if (last_size_.IsEmpty())
       last_size_ = new_size;
     else if (!did_size_change_more_than_once_ && new_size != last_size_)
       did_size_change_more_than_once_ = true;
     Widget::OnNativeWidgetSizeChanged(new_size);
   }
 
  private:
   bool did_size_change_more_than_once_;
   gfx::Size last_size_;
@@ skipping 16 matching lines @@
   params.show_state = ui::SHOW_STATE_MAXIMIZED;
   params.bounds = gfx::Rect(10, 10, 100, 200);
   widget->Init(params);
   EXPECT_FALSE(widget->did_size_change_more_than_once());
   widget->CloseNow();
 }
 
 class PropertyTestLayoutManager : public TestLayoutManagerBase {
  public:
   PropertyTestLayoutManager() : added_(false) {}
-  virtual ~PropertyTestLayoutManager() {}
+  ~PropertyTestLayoutManager() override {}
 
   bool added() const { return added_; }
 
  private:
   // aura::LayoutManager:
-  virtual void OnWindowAddedToLayout(aura::Window* child) override {
+  void OnWindowAddedToLayout(aura::Window* child) override {
     EXPECT_TRUE(child->GetProperty(aura::client::kCanMaximizeKey));
     EXPECT_TRUE(child->GetProperty(aura::client::kCanMinimizeKey));
     EXPECT_TRUE(child->GetProperty(aura::client::kCanResizeKey));
     added_ = true;
   }
 
   bool added_;
 
   DISALLOW_COPY_AND_ASSIGN(PropertyTestLayoutManager);
 };
 
 class PropertyTestWidgetDelegate : public views::WidgetDelegate {
  public:
   explicit PropertyTestWidgetDelegate(Widget* widget) : widget_(widget) {}
-  virtual ~PropertyTestWidgetDelegate() {}
+  ~PropertyTestWidgetDelegate() override {}
 
  private:
   // views::WidgetDelegate:
-  virtual bool CanMaximize() const override {
-    return true;
-  }
-  virtual bool CanMinimize() const override {
-    return true;
-  }
-  virtual bool CanResize() const override {
-    return true;
-  }
-  virtual void DeleteDelegate() override {
-    delete this;
-  }
-  virtual Widget* GetWidget() override {
-    return widget_;
-  }
-  virtual const Widget* GetWidget() const override {
-    return widget_;
-  }
+  bool CanMaximize() const override { return true; }
+  bool CanMinimize() const override { return true; }
+  bool CanResize() const override { return true; }
+  void DeleteDelegate() override { delete this; }
+  Widget* GetWidget() override { return widget_; }
+  const Widget* GetWidget() const override { return widget_; }
 
   Widget* widget_;
   DISALLOW_COPY_AND_ASSIGN(PropertyTestWidgetDelegate);
 };
 
 // Verifies that the kCanMaximizeKey/kCanMinimizeKey/kCanResizeKey have the
 // correct value when added to the layout manager.
 TEST_F(NativeWidgetAuraTest, TestPropertiesWhenAddedToLayout) {
   root_window()->SetBounds(gfx::Rect(0, 0, 640, 480));
   PropertyTestLayoutManager* layout_manager = new PropertyTestLayoutManager();
@@ skipping 38 matching lines @@
   }
 
   void clear_got_gesture_event() {
     got_gesture_event_ = false;
   }
   bool got_gesture_event() const {
     return got_gesture_event_;
   }
 
   // View overrides:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     got_gesture_event_ = true;
     if (consume_gesture_event_)
       event->StopPropagation();
   }
 
  private:
   // Was OnGestureEvent() invoked?
   bool got_gesture_event_;
 
   // Dictates what OnGestureEvent() returns.
@@ skipping 141 matching lines @@
   widget->Show();
   widget->Close();
   base::MessageLoop::current()->RunUntilIdle();
   widget->GetNativeTheme();  // Shouldn't crash.
 }
 
 // Used to track calls to WidgetDelegate::OnWidgetMove().
 class MoveTestWidgetDelegate : public WidgetDelegateView {
  public:
   MoveTestWidgetDelegate() : got_move_(false) {}
-  virtual ~MoveTestWidgetDelegate() {}
+  ~MoveTestWidgetDelegate() override {}
 
   void ClearGotMove() { got_move_ = false; }
   bool got_move() const { return got_move_; }
 
   // WidgetDelegate overrides:
-  virtual void OnWidgetMove() override { got_move_ = true; }
+  void OnWidgetMove() override { got_move_ = true; }
 
  private:
   bool got_move_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveTestWidgetDelegate);
 };
 
 // This test simulates what happens when a window is normally maximized. That
 // is, it's layer is acquired for animation then the window is maximized.
 // Acquiring the layer resets the bounds of the window. This test verifies the
 // Widget is still notified correctly of a move in this case.
 TEST_F(NativeWidgetAuraTest, OnWidgetMovedInvokedAfterAcquireLayer) {
   // |delegate| deletes itself when the widget is destroyed.
   MoveTestWidgetDelegate* delegate = new MoveTestWidgetDelegate;
   Widget* widget =
       Widget::CreateWindowWithContextAndBounds(delegate,
                                                root_window(),
                                                gfx::Rect(10, 10, 100, 200));
   widget->Show();
   delegate->ClearGotMove();
   // Simulate a maximize with animation.
   delete widget->GetNativeView()->RecreateLayer().release();
   widget->SetBounds(gfx::Rect(0, 0, 500, 500));
   EXPECT_TRUE(delegate->got_move());
   widget->CloseNow();
 }
 
 }  // namespace
 }  // namespace views