replace OVERRIDE and FINAL with override and 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 {
+  virtual 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 WillProcessTask(const base::PendingTask& pending_task) override {
   }
-  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void DidProcessTask(const base::PendingTask& pending_task) override {
   }
 };
 MessageLoopObserver message_loop_observer;
 
 class TaskObserverPerfTest : public TaskPerfTest {
  public:
-  virtual void Init() OVERRIDE {
+  virtual 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);
 }
 
 // Class to test our WaitableEvent performance by signaling back and fort.
 // WaitableEvent is templated so we can also compare with other versions.
 template <typename WaitableEventType>
 class EventPerfTest : public ThreadPerfTest {
  public:
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     for (size_t i = 0; i < threads_.size(); i++)
       events_.push_back(new WaitableEventType(false, false));
   }
 
-  virtual void Reset() OVERRIDE { events_.clear(); }
+  virtual void Reset() override { events_.clear(); }
 
   void WaitAndSignalOnThread(size_t event) {
     size_t next_event = (event + 1) % events_.size();
     int my_hops = 0;
     do {
       events_[event]->Wait();
       my_hops = --remaining_hops_;  // We own 'hops' between Wait and Signal.
       events_[next_event]->Signal();
     } while (my_hops > 0);
     // Once we are done, all threads will signal as hops passes zero.
     // We only signal completion once, on the thread that reaches zero.
     if (!my_hops)
       FinishMeasurement();
   }
 
-  virtual void PingPong(int hops) OVERRIDE {
+  virtual void PingPong(int hops) override {
     remaining_hops_ = hops;
     for (size_t i = 0; i < threads_.size(); i++) {
       threads_[i]->message_loop_proxy()->PostTask(
           FROM_HERE,
           base::Bind(&EventPerfTest::WaitAndSignalOnThread,
                      base::Unretained(this),
                      i));
     }
 
     // Kick off the Signal ping-ponging.
@@ skipping 94 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base