Standardize usage of virtual/override/final in ui/

ui/app_list/search/mixer_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 <string>
 
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/search/history_types.h"
 #include "ui/app_list/search/mixer.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/search_result.h"
 
 namespace app_list {
 namespace test {
 
 class TestSearchResult : public SearchResult {
  public:
   TestSearchResult(const std::string& id, double relevance)
       : instance_id_(instantiation_count++) {
     set_id(id);
     set_title(base::UTF8ToUTF16(id));
     set_relevance(relevance);
   }
-  virtual ~TestSearchResult() {}
+  ~TestSearchResult() override {}
 
   // SearchResult overrides:
-  virtual void Open(int event_flags) override {}
-  virtual void InvokeAction(int action_index, int event_flags) override {}
-  virtual scoped_ptr<SearchResult> Duplicate() override {
+  void Open(int event_flags) override {}
+  void InvokeAction(int action_index, int event_flags) override {}
+  scoped_ptr<SearchResult> Duplicate() override {
     return scoped_ptr<SearchResult>(new TestSearchResult(id(), relevance()));
   }
 
   // For reference equality testing. (Addresses cannot be used to test reference
   // equality because it is possible that an object will be allocated at the
   // same address as a previously deleted one.)
   static int GetInstanceId(SearchResult* result) {
     return static_cast<const TestSearchResult*>(result)->instance_id_;
   }
 
  private:
   static int instantiation_count;
 
   int instance_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSearchResult);
 };
 int TestSearchResult::instantiation_count = 0;
 
 class TestSearchProvider : public SearchProvider {
  public:
   explicit TestSearchProvider(const std::string& prefix)
       : prefix_(prefix), count_(0) {}
-  virtual ~TestSearchProvider() {}
+  ~TestSearchProvider() override {}
 
   // SearchProvider overrides:
-  virtual void Start(const base::string16& query) override {
+  void Start(const base::string16& query) override {
     ClearResults();
     for (size_t i = 0; i < count_; ++i) {
       const std::string id =
           base::StringPrintf("%s%d", prefix_.c_str(), static_cast<int>(i));
       const double relevance = 1.0 - i / 10.0;
       Add(scoped_ptr<SearchResult>(new TestSearchResult(id, relevance)).Pass());
     }
   }
-  virtual void Stop() override {}
+  void Stop() override {}
 
   void set_prefix(const std::string& prefix) { prefix_ = prefix; }
   void set_count(size_t count) { count_ = count; }
 
  private:
   std::string prefix_;
   size_t count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSearchProvider);
 };
@@ skipping 192 matching lines @@
   EXPECT_EQ(old_ui_result_ids[0],
             TestSearchResult::GetInstanceId(ui_results.GetItemAt(3)));
   EXPECT_EQ(old_ui_result_ids[1],
             TestSearchResult::GetInstanceId(ui_results.GetItemAt(0)));
   EXPECT_EQ(old_ui_result_ids[2],
             TestSearchResult::GetInstanceId(ui_results.GetItemAt(2)));
 }
 
 }  // namespace test
 }  // namespace app_list