replace OVERRIDE and FINAL with override and final in ui/

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 {
+  virtual 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 {
+  virtual 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 22 matching lines @@
  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 {
+                              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 33 matching lines @@
   }
 
   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 {
+                               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 {
+  virtual void OnBeforeUserAction(Textfield* sender) override {
     ++on_before_user_action_;
   }
 
-  virtual void OnAfterUserAction(Textfield* sender) OVERRIDE {
+  virtual void OnAfterUserAction(Textfield* sender) override {
     ++on_after_user_action_;
   }
 
-  virtual void OnAfterCutOrCopy(ui::ClipboardType clipboard_type) OVERRIDE {
+  virtual 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 419 matching lines @@
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Install a TextEditKeyBindingsDelegateAuraLinux that does nothing.
   class TestDelegate : public ui::TextEditKeyBindingsDelegateAuraLinux {
    public:
     TestDelegate() {}
     virtual ~TestDelegate() {}
 
     virtual bool MatchEvent(
         const ui::Event& event,
-        std::vector<ui::TextEditCommandAuraLinux>* commands) OVERRIDE {
+        std::vector<ui::TextEditCommandAuraLinux>* commands) override {
       return false;
     }
 
    private:
     DISALLOW_COPY_AND_ASSIGN(TestDelegate);
   };
 
   TestDelegate delegate;
   ui::SetTextEditKeyBindingsDelegate(&delegate);
 #endif
@@ skipping 1418 matching lines @@
   TextfieldDestroyerController controller(textfield_);
   EXPECT_TRUE(controller.target());
 
   // Send a key to trigger OnKeyEvent().
   SendKeyEvent('X');
 
   EXPECT_FALSE(controller.target());
 }
 
 }  // namespace views