Standardize usage of virtual/override/final specifiers.

ui/views/focus/focus_manager_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/focus/focus_manager.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 30 matching lines @@
 };
 
 class SimpleTestView : public View {
  public:
   SimpleTestView(std::vector<FocusTestEvent>* event_list, int view_id)
       : event_list_(event_list) {
     SetFocusable(true);
     set_id(view_id);
   }
 
-  virtual void OnFocus() override {
+  void OnFocus() override {
     event_list_->push_back(FocusTestEvent(ON_FOCUS, id()));
   }
 
-  virtual void OnBlur() override {
+  void OnBlur() override {
     event_list_->push_back(FocusTestEvent(ON_BLUR, id()));
   }
 
  private:
   std::vector<FocusTestEvent>* event_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleTestView);
 };
 
 // Tests that the appropriate Focus related methods are called when a View
@@ skipping 92 matching lines @@
 }
 
 // Counts accelerator calls.
 class TestAcceleratorTarget : public ui::AcceleratorTarget {
  public:
   explicit TestAcceleratorTarget(bool process_accelerator)
       : accelerator_count_(0),
         process_accelerator_(process_accelerator),
         can_handle_accelerators_(true) {}
 
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
     ++accelerator_count_;
     return process_accelerator_;
   }
 
-  virtual bool CanHandleAccelerators() const override {
+  bool CanHandleAccelerators() const override {
     return can_handle_accelerators_;
   }
 
   int accelerator_count() const { return accelerator_count_; }
 
   void set_can_handle_accelerators(bool can_handle_accelerators) {
     can_handle_accelerators_ = can_handle_accelerators;
   }
 
  private:
@@ skipping 234 matching lines @@
 // Unregisters itself when its accelerator is invoked.
 class SelfUnregisteringAcceleratorTarget : public ui::AcceleratorTarget {
  public:
   SelfUnregisteringAcceleratorTarget(ui::Accelerator accelerator,
                                      FocusManager* focus_manager)
       : accelerator_(accelerator),
         focus_manager_(focus_manager),
         accelerator_count_(0) {
   }
 
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
     ++accelerator_count_;
     focus_manager_->UnregisterAccelerator(accelerator, this);
     return true;
   }
 
-  virtual bool CanHandleAccelerators() const override {
-    return true;
-  }
+  bool CanHandleAccelerators() const override { return true; }
 
   int accelerator_count() const { return accelerator_count_; }
 
  private:
   ui::Accelerator accelerator_;
   FocusManager* focus_manager_;
   int accelerator_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget);
 };
@@ skipping 28 matching lines @@
  protected:
   typedef std::vector<std::string> DtorTrackVector;
 
   class FocusManagerDtorTracked : public FocusManager {
    public:
     FocusManagerDtorTracked(Widget* widget, DtorTrackVector* dtor_tracker)
       : FocusManager(widget, NULL /* delegate */),
         dtor_tracker_(dtor_tracker) {
     }
 
-    virtual ~FocusManagerDtorTracked() {
+    ~FocusManagerDtorTracked() override {
       dtor_tracker_->push_back("FocusManagerDtorTracked");
     }
 
     DtorTrackVector* dtor_tracker_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(FocusManagerDtorTracked);
   };
 
   class TestFocusManagerFactory : public FocusManagerFactory {
    public:
     explicit TestFocusManagerFactory(DtorTrackVector* dtor_tracker)
         : dtor_tracker_(dtor_tracker) {
     }
 
-    virtual FocusManager* CreateFocusManager(Widget* widget,
-                                             bool desktop_widget) override {
+    FocusManager* CreateFocusManager(Widget* widget,
+                                     bool desktop_widget) override {
       return new FocusManagerDtorTracked(widget, dtor_tracker_);
     }
 
    private:
     DtorTrackVector* dtor_tracker_;
     DISALLOW_COPY_AND_ASSIGN(TestFocusManagerFactory);
   };
 
   class LabelButtonDtorTracked : public LabelButton {
    public:
     LabelButtonDtorTracked(const base::string16& text,
                            DtorTrackVector* dtor_tracker)
         : LabelButton(NULL, text),
           dtor_tracker_(dtor_tracker) {
       SetStyle(STYLE_BUTTON);
     };
-    virtual ~LabelButtonDtorTracked() {
+    ~LabelButtonDtorTracked() override {
       dtor_tracker_->push_back("LabelButtonDtorTracked");
     }
 
     DtorTrackVector* dtor_tracker_;
   };
 
   class WindowDtorTracked : public Widget {
    public:
     explicit WindowDtorTracked(DtorTrackVector* dtor_tracker)
         : dtor_tracker_(dtor_tracker) {
     }
 
-    virtual ~WindowDtorTracked() {
+    ~WindowDtorTracked() override {
       dtor_tracker_->push_back("WindowDtorTracked");
     }
 
     DtorTrackVector* dtor_tracker_;
   };
 
-  virtual void SetUp() {
+  void SetUp() override {
     ViewsTestBase::SetUp();
     FocusManagerFactory::Install(new TestFocusManagerFactory(&dtor_tracker_));
     // Create WindowDtorTracked that uses FocusManagerDtorTracked.
     Widget* widget = new WindowDtorTracked(&dtor_tracker_);
     Widget::InitParams params;
     params.delegate = this;
     params.bounds = gfx::Rect(0, 0, 100, 100);
     widget->Init(params);
 
     tracked_focus_manager_ =
         static_cast<FocusManagerDtorTracked*>(GetFocusManager());
     widget->Show();
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     FocusManagerFactory::Install(NULL);
     ViewsTestBase::TearDown();
   }
 
   FocusManager* tracked_focus_manager_;
   DtorTrackVector dtor_tracker_;
 };
 
 namespace {
 
 class FocusInAboutToRequestFocusFromTabTraversalView : public View {
  public:
   FocusInAboutToRequestFocusFromTabTraversalView() : view_to_focus_(NULL) {}
 
   void set_view_to_focus(View* view) { view_to_focus_ = view; }
 
-  virtual void AboutToRequestFocusFromTabTraversal(bool reverse) override {
+  void AboutToRequestFocusFromTabTraversal(bool reverse) override {
     view_to_focus_->RequestFocus();
   }
 
  private:
   views::View* view_to_focus_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusInAboutToRequestFocusFromTabTraversalView);
 };
 }  // namespace
 
@@ skipping 114 matching lines @@
   EXPECT_EQ(v2, GetWidget()->GetFocusManager()->GetStoredFocusView());
 }
 
 namespace  {
 
 class FocusManagerArrowKeyTraversalTest : public FocusManagerTest {
  public:
   FocusManagerArrowKeyTraversalTest()
       : previous_arrow_key_traversal_enabled_(false) {
   }
-  virtual ~FocusManagerArrowKeyTraversalTest() {}
+  ~FocusManagerArrowKeyTraversalTest() override {}
 
   // FocusManagerTest overrides:
-  virtual void SetUp() override {
+  void SetUp() override {
     FocusManagerTest::SetUp();
 
     previous_arrow_key_traversal_enabled_ =
       FocusManager::arrow_key_traversal_enabled();
   }
-  virtual void TearDown() override {
+  void TearDown() override {
     FocusManager::set_arrow_key_traversal_enabled(
         previous_arrow_key_traversal_enabled_);
     FocusManagerTest::TearDown();
   }
 
  private:
   bool previous_arrow_key_traversal_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerArrowKeyTraversalTest);
 };
@@ skipping 53 matching lines @@
   GetFocusManager()->StoreFocusedView(true);
   EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView());
   EXPECT_TRUE(GetFocusManager()->RestoreFocusedView());
   EXPECT_EQ(&view, GetFocusManager()->GetStoredFocusView());
 }
 
 class TextInputTestView : public View {
  public:
   TextInputTestView() {}
 
-  virtual ui::TextInputClient* GetTextInputClient() override {
+  ui::TextInputClient* GetTextInputClient() override {
     return &text_input_client_;
   }
 
  private:
   ui::DummyTextInputClient text_input_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TextInputTestView);
 };
 
 TEST_F(FocusManagerTest, TextInputClient) {
@@ skipping 38 matching lines @@
 
 namespace {
 
 // Trivial WidgetDelegate implementation that allows setting return value of
 // ShouldAdvanceFocusToTopLevelWidget().
 class AdvanceFocusWidgetDelegate : public WidgetDelegate {
  public:
   explicit AdvanceFocusWidgetDelegate(Widget* widget)
       : widget_(widget),
         should_advance_focus_to_parent_(false) {}
-  virtual ~AdvanceFocusWidgetDelegate() {}
+  ~AdvanceFocusWidgetDelegate() override {}
 
   void set_should_advance_focus_to_parent(bool value) {
     should_advance_focus_to_parent_ = value;
   }
 
   // WidgetDelegate overrides:
-  virtual bool ShouldAdvanceFocusToTopLevelWidget() const override {
+  bool ShouldAdvanceFocusToTopLevelWidget() const override {
     return should_advance_focus_to_parent_;
   }
-  virtual Widget* GetWidget() override { return widget_; }
-  virtual const Widget* GetWidget() const override { return widget_; }
+  Widget* GetWidget() override { return widget_; }
+  const Widget* GetWidget() const override { return widget_; }
 
  private:
   Widget* widget_;
   bool should_advance_focus_to_parent_;
 
   DISALLOW_COPY_AND_ASSIGN(AdvanceFocusWidgetDelegate);
 };
 
 }  // namespace
 
@@ skipping 41 matching lines @@
   EXPECT_EQ(view1, GetFocusManager()->GetFocusedView());
 
   // Allow focus to go to the parent, and focus backwards which should now move
   // up |widget_view| (in the parent).
   delegate->set_should_advance_focus_to_parent(true);
   GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(widget_view, GetFocusManager()->GetFocusedView());
 }
 
 }  // namespace views