Standardize usage of virtual/override/final in base/

base/threading/thread_perftest.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 "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
@@ skipping 105 matching lines @@
  private:
   base::WaitableEvent done_;
 };
 
 // Class to test task performance by posting empty tasks back and forth.
 class TaskPerfTest : public ThreadPerfTest {
   base::Thread* NextThread(int count) {
     return threads_[count % threads_.size()];
   }
 
-  virtual void PingPong(int hops) override {
+  void PingPong(int hops) override {
     if (!hops) {
       FinishMeasurement();
       return;
     }
     NextThread(hops)->message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &ThreadPerfTest::PingPong, base::Unretained(this), hops - 1));
   }
 };
 
 // This tries to test the 'best-case' as well as the 'worst-case' task posting
 // performance. The best-case keeps one thread alive such that it never yeilds,
 // while the worse-case forces a context switch for every task. Four threads are
 // used to ensure the threads do yeild (with just two it might be possible for
 // both threads to stay awake if they can signal each other fast enough).
 TEST_F(TaskPerfTest, TaskPingPong) {
   RunPingPongTest("1_Task_Threads", 1);
   RunPingPongTest("4_Task_Threads", 4);
 }
 
 
 // Same as above, but add observers to test their perf impact.
 class MessageLoopObserver : public base::MessageLoop::TaskObserver {
  public:
-  virtual void WillProcessTask(const base::PendingTask& pending_task) override {
-  }
-  virtual void DidProcessTask(const base::PendingTask& pending_task) override {
-  }
+  void WillProcessTask(const base::PendingTask& pending_task) override {}
+  void DidProcessTask(const base::PendingTask& pending_task) override {}
 };
 MessageLoopObserver message_loop_observer;
 
 class TaskObserverPerfTest : public TaskPerfTest {
  public:
-  virtual void Init() override {
+  void Init() override {
     TaskPerfTest::Init();
     for (size_t i = 0; i < threads_.size(); i++) {
       threads_[i]->message_loop()->AddTaskObserver(&message_loop_observer);
     }
   }
 };
 
 TEST_F(TaskObserverPerfTest, TaskPingPong) {
   RunPingPongTest("1_Task_Threads_With_Observer", 1);
   RunPingPongTest("4_Task_Threads_With_Observer", 4);
@@ skipping 133 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base