Standardize usage of virtual/override/final specifiers.

ui/views/controls/textfield/textfield_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 "ui/views/controls/textfield/textfield.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 46 matching lines @@
 
 // A Textfield wrapper to intercept OnKey[Pressed|Released]() ressults.
 class TestTextfield : public views::Textfield {
  public:
   TestTextfield()
      : Textfield(),
        key_handled_(false),
        key_received_(false),
        weak_ptr_factory_(this) {}
 
-  virtual bool OnKeyPressed(const ui::KeyEvent& e) override {
+  bool OnKeyPressed(const ui::KeyEvent& e) override {
     key_received_ = true;
 
     // Since OnKeyPressed() might destroy |this|, get a weak pointer and
     // verify it isn't null before writing the bool value to key_handled_.
     base::WeakPtr<TestTextfield> textfield(weak_ptr_factory_.GetWeakPtr());
     bool key = views::Textfield::OnKeyPressed(e);
 
     if (!textfield)
       return key;
 
     key_handled_ = key;
 
     return key_handled_;
   }
 
-  virtual bool OnKeyReleased(const ui::KeyEvent& e) override {
+  bool OnKeyReleased(const ui::KeyEvent& e) override {
     key_received_ = true;
     key_handled_ = views::Textfield::OnKeyReleased(e);
     return key_handled_;
   }
 
   bool key_handled() const { return key_handled_; }
   bool key_received() const { return key_received_; }
 
   void clear() { key_received_ = key_handled_ = false; }
 
@@ skipping 21 matching lines @@
 class TextfieldDestroyerController : public views::TextfieldController {
  public:
   explicit TextfieldDestroyerController(views::Textfield* target)
       : target_(target) {
     target_->set_controller(this);
   }
 
   views::Textfield* target() { return target_.get(); }
 
   // views::TextfieldController:
-  virtual bool HandleKeyEvent(views::Textfield* sender,
-                              const ui::KeyEvent& key_event) override {
+  bool HandleKeyEvent(views::Textfield* sender,
+                      const ui::KeyEvent& key_event) override {
     target_.reset();
     return false;
   }
 
  private:
   scoped_ptr<views::Textfield> target_;
 };
 
 base::string16 GetClipboardText(ui::ClipboardType type) {
   base::string16 text;
@@ skipping 15 matching lines @@
       : widget_(NULL),
         textfield_(NULL),
         model_(NULL),
         input_method_(NULL),
         on_before_user_action_(0),
         on_after_user_action_(0),
         copied_to_clipboard_(ui::CLIPBOARD_TYPE_LAST) {
   }
 
   // ::testing::Test:
-  virtual void SetUp() {
-    ViewsTestBase::SetUp();
-  }
+  void SetUp() override { ViewsTestBase::SetUp(); }

[msw, 2014/10/27 20:43:57]

nit: I guess this can be removed altogether!

[dcheng, 2014/10/27 20:46:36]

o.O

Let me clean this up in a followup, given the number of patches in flight, it'll
make my life a bit easier.

[msw, 2014/10/27 20:47:44]

Even doing this in a followup is optional for you.

 
-  virtual void TearDown() {
+  void TearDown() override {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   ui::ClipboardType GetAndResetCopiedToClipboard() {
     ui::ClipboardType clipboard_type = copied_to_clipboard_;
     copied_to_clipboard_ = ui::CLIPBOARD_TYPE_LAST;
     return clipboard_type;
   }
 
   // TextfieldController:
-  virtual void ContentsChanged(Textfield* sender,
-                               const base::string16& new_contents) override {
+  void ContentsChanged(Textfield* sender,
+                       const base::string16& new_contents) override {
     // Paste calls TextfieldController::ContentsChanged() explicitly even if the
     // paste action did not change the content. So |new_contents| may match
     // |last_contents_|. For more info, see http://crbug.com/79002
     last_contents_ = new_contents;
   }
 
-  virtual void OnBeforeUserAction(Textfield* sender) override {
+  void OnBeforeUserAction(Textfield* sender) override {
     ++on_before_user_action_;
   }
 
-  virtual void OnAfterUserAction(Textfield* sender) override {
+  void OnAfterUserAction(Textfield* sender) override {
     ++on_after_user_action_;
   }
 
-  virtual void OnAfterCutOrCopy(ui::ClipboardType clipboard_type) override {
+  void OnAfterCutOrCopy(ui::ClipboardType clipboard_type) override {
     copied_to_clipboard_ = clipboard_type;
   }
 
   void InitTextfield() {
     InitTextfields(1);
   }
 
   void InitTextfields(int count) {
     ASSERT_FALSE(textfield_);
     textfield_ = new TestTextfield();
@@ skipping 415 matching lines @@
 
 // Tests that default key bindings are handled even with a delegate installed.
 TEST_F(TextfieldTest, OnKeyPressBinding) {
   InitTextfield();
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Install a TextEditKeyBindingsDelegateAuraLinux that does nothing.
   class TestDelegate : public ui::TextEditKeyBindingsDelegateAuraLinux {
    public:
     TestDelegate() {}
-    virtual ~TestDelegate() {}
+    ~TestDelegate() override {}
 
-    virtual bool MatchEvent(
+    bool MatchEvent(
         const ui::Event& event,
         std::vector<ui::TextEditCommandAuraLinux>* commands) override {
       return false;
     }
 
    private:
     DISALLOW_COPY_AND_ASSIGN(TestDelegate);
   };
 
   TestDelegate delegate;
@@ skipping 1420 matching lines @@
   TextfieldDestroyerController controller(textfield_);
   EXPECT_TRUE(controller.target());
 
   // Send a key to trigger OnKeyEvent().
   SendKeyEvent('X');
 
   EXPECT_FALSE(controller.target());
 }
 
 }  // namespace views