Standardize usage of virtual/override/final specifiers.

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 17 matching lines @@
 namespace {
 
 // An dummy implementation of MenuRunnerHandler to check if the dropdown menu is
 // shown or not.
 class TestMenuRunnerHandler : public MenuRunnerHandler {
  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 {
+  MenuRunner::RunResult RunMenuAt(Widget* parent,
+                                  MenuButton* button,
+                                  const gfx::Rect& bounds,
+                                  MenuAnchorPosition anchor,
+                                  ui::MenuSourceType source_type,
+                                  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 {
+  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 {
+  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() {}
+  ~TestComboboxModel() override {}
 
   static const int kItemCount = 10;
 
   // ui::ComboboxModel:
-  virtual int GetItemCount() const override {
-    return kItemCount;
-  }
-  virtual base::string16 GetItemAt(int index) override {
+  int GetItemCount() const override { return kItemCount; }
+  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 {
+  bool IsItemSeparatorAt(int index) override {
     return separators_.find(index) != separators_.end();
   }
 
-  virtual int GetDefaultIndex() const override {
+  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() {}
+  ~VectorComboboxModel() override {}
 
   // ui::ComboboxModel:
-  virtual int GetItemCount() const override {
-    return (int)values_->size();
-  }
-  virtual base::string16 GetItemAt(int index) override {
+  int GetItemCount() const override { return (int)values_->size(); }
+  base::string16 GetItemAt(int index) override {
     return ASCIIToUTF16(values_->at(index));
   }
-  virtual bool IsItemSeparatorAt(int index) override {
-    return false;
-  }
+  bool IsItemSeparatorAt(int index) override { return false; }
 
  private:
   std::vector<std::string>* values_;
 };
 
 class EvilListener : public ComboboxListener {
  public:
   EvilListener() : deleted_(false) {}
-  virtual ~EvilListener() {};
+  ~EvilListener() override{};
 
   // ComboboxListener:
-  virtual void OnPerformAction(Combobox* combobox) override {
+  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() {}
+  ~TestComboboxListener() override {}
 
-  virtual void OnPerformAction(views::Combobox* combobox) override {
+  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 {
+  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