Standardize usage of virtual/override/final in ui/

ui/app_list/pagination_model_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/app_list/pagination_model.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/pagination_model_observer.h"
 
 namespace app_list {
 namespace test {
 
 class TestPaginationModelObserver : public PaginationModelObserver {
  public:
   TestPaginationModelObserver()
       : model_(NULL),
         expected_page_selection_(0),
         expected_transition_start_(0),
         expected_transition_end_(0),
         transition_page_(-1) {
     Reset();
   }
-  virtual ~TestPaginationModelObserver() {}
+  ~TestPaginationModelObserver() override {}
 
   void Reset() {
     selection_count_ = 0;
     transition_start_count_ = 0;
     transition_end_count_ = 0;
     selected_pages_.clear();
   }
 
   void set_model(PaginationModel* model) { model_ = model; }
 
@@ skipping 14 matching lines @@
   int transition_end_count() const { return transition_end_count_; }
 
  private:
   void AppendSelectedPage(int page) {
     if (selected_pages_.length())
       selected_pages_.append(std::string(" "));
     selected_pages_.append(base::StringPrintf("%d", page));
   }
 
   // PaginationModelObserver overrides:
-  virtual void TotalPagesChanged() override {}
-  virtual void SelectedPageChanged(int old_selected,
-                                   int new_selected) override {
+  void TotalPagesChanged() override {}
+  void SelectedPageChanged(int old_selected, int new_selected) override {
     AppendSelectedPage(new_selected);
     ++selection_count_;
     if (expected_page_selection_ &&
         selection_count_ == expected_page_selection_) {
       base::MessageLoop::current()->Quit();
     }
   }
 
-  virtual void TransitionStarted() override {
-  }
+  void TransitionStarted() override {}
 
-  virtual void TransitionChanged() override {
+  void TransitionChanged() override {
     if (transition_page_ == -1 ||
         model_->transition().target_page == transition_page_) {
       if (model_->transition().progress == 0)
         ++transition_start_count_;
       if (model_->transition().progress == 1)
         ++transition_end_count_;
     }
 
     if ((expected_transition_start_ &&
          transition_start_count_ == expected_transition_start_) ||
@@ skipping 336 matching lines @@
   EXPECT_EQ(1, pagination_.selected_page());
 
   // But if the currently selected_page exceeds the total number of pages,
   // it automatically switches to the last page.
   pagination_.SetTotalPages(1);
   EXPECT_EQ(0, pagination_.selected_page());
 }
 
 }  // namespace test
 }  // namespace app_list