replace OVERRIDE and FINAL with override and final in ui/

ui/views/controls/combobox/combobox_unittest.cc

 // Copyright 2013 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/combobox/combobox.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 22 matching lines @@
  public:
   TestMenuRunnerHandler() : executed_(false) {}
 
   bool executed() const { return executed_; }
 
   virtual MenuRunner::RunResult RunMenuAt(Widget* parent,
                                           MenuButton* button,
                                           const gfx::Rect& bounds,
                                           MenuAnchorPosition anchor,
                                           ui::MenuSourceType source_type,
-                                          int32 types) OVERRIDE {
+                                          int32 types) override {
     executed_ = true;
     return MenuRunner::NORMAL_EXIT;
   }
 
  private:
   bool executed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMenuRunnerHandler);
 };
 
 // A wrapper of Combobox to intercept the result of OnKeyPressed() and
 // OnKeyReleased() methods.
 class TestCombobox : public Combobox {
  public:
   explicit TestCombobox(ui::ComboboxModel* model)
       : Combobox(model),
         key_handled_(false),
         key_received_(false) {}
 
-  virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE {
+  virtual bool OnKeyPressed(const ui::KeyEvent& e) override {
     key_received_ = true;
     key_handled_ = Combobox::OnKeyPressed(e);
     return key_handled_;
   }
 
-  virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE {
+  virtual bool OnKeyReleased(const ui::KeyEvent& e) override {
     key_received_ = true;
     key_handled_ = Combobox::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;
   }
 
  private:
   bool key_handled_;
   bool key_received_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCombobox);
 };
 
 // A concrete class is needed to test the combobox.
 class TestComboboxModel : public ui::ComboboxModel {
  public:
   TestComboboxModel() {}
   virtual ~TestComboboxModel() {}
 
   static const int kItemCount = 10;
 
   // ui::ComboboxModel:
-  virtual int GetItemCount() const OVERRIDE {
+  virtual int GetItemCount() const override {
     return kItemCount;
   }
-  virtual base::string16 GetItemAt(int index) OVERRIDE {
+  virtual base::string16 GetItemAt(int index) override {
     if (IsItemSeparatorAt(index)) {
       NOTREACHED();
       return ASCIIToUTF16("SEPARATOR");
     }
     return ASCIIToUTF16(index % 2 == 0 ? "PEANUT BUTTER" : "JELLY");
   }
-  virtual bool IsItemSeparatorAt(int index) OVERRIDE {
+  virtual bool IsItemSeparatorAt(int index) override {
     return separators_.find(index) != separators_.end();
   }
 
-  virtual int GetDefaultIndex() const OVERRIDE {
+  virtual int GetDefaultIndex() const override {
     // Return the first index that is not a separator.
     for (int index = 0; index < kItemCount; ++index) {
       if (separators_.find(index) == separators_.end())
         return index;
     }
     NOTREACHED();
     return 0;
   }
 
   void SetSeparators(const std::set<int>& separators) {
     separators_ = separators;
   }
 
  private:
   std::set<int> separators_;
 
   DISALLOW_COPY_AND_ASSIGN(TestComboboxModel);
 };
 
 // A combobox model which refers to a vector.
 class VectorComboboxModel : public ui::ComboboxModel {
  public:
   explicit VectorComboboxModel(std::vector<std::string>* values)
       : values_(values) {}
   virtual ~VectorComboboxModel() {}
 
   // ui::ComboboxModel:
-  virtual int GetItemCount() const OVERRIDE {
+  virtual int GetItemCount() const override {
     return (int)values_->size();
   }
-  virtual base::string16 GetItemAt(int index) OVERRIDE {
+  virtual base::string16 GetItemAt(int index) override {
     return ASCIIToUTF16(values_->at(index));
   }
-  virtual bool IsItemSeparatorAt(int index) OVERRIDE {
+  virtual bool IsItemSeparatorAt(int index) override {
     return false;
   }
 
  private:
   std::vector<std::string>* values_;
 };
 
 class EvilListener : public ComboboxListener {
  public:
   EvilListener() : deleted_(false) {}
   virtual ~EvilListener() {};
 
   // ComboboxListener:
-  virtual void OnPerformAction(Combobox* combobox) OVERRIDE {
+  virtual void OnPerformAction(Combobox* combobox) override {
     delete combobox;
     deleted_ = true;
   }
 
   bool deleted() const { return deleted_; }
 
  private:
   bool deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(EvilListener);
 };
 
 class TestComboboxListener : public views::ComboboxListener {
  public:
   TestComboboxListener() : perform_action_index_(-1), actions_performed_(0) {}
   virtual ~TestComboboxListener() {}
 
-  virtual void OnPerformAction(views::Combobox* combobox) OVERRIDE {
+  virtual void OnPerformAction(views::Combobox* combobox) override {
     perform_action_index_ = combobox->selected_index();
     actions_performed_++;
   }
 
   int perform_action_index() const {
     return perform_action_index_;
   }
 
   bool on_perform_action_called() const {
     return actions_performed_ > 0;
@@ skipping 10 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(TestComboboxListener);
 };
 
 }  // namespace
 
 class ComboboxTest : public ViewsTestBase {
  public:
   ComboboxTest() : widget_(NULL), combobox_(NULL) {}
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (widget_)
       widget_->Close();
     ViewsTestBase::TearDown();
   }
 
   void InitCombobox(const std::set<int>* separators) {
     model_.reset(new TestComboboxModel());
 
     if (separators)
       model_->SetSeparators(*separators);
@@ skipping 472 matching lines @@
   combobox_->OnBlur();
 
   // Type the first character of "PEANUT BUTTER", which should change the
   // selected index and perform an action.
   combobox_->GetTextInputClient()->InsertChar('P', ui::EF_NONE);
   EXPECT_EQ(2, listener.actions_performed());
   EXPECT_EQ(2, listener.perform_action_index());
 }
 
 }  // namespace views