replace 'virtual ... OVERRIDE' with '... override'

base/threading/thread_collision_warner_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 "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_collision_warner.h"
@@ skipping 23 matching lines @@
 namespace {
 
 // This is the asserter used with ThreadCollisionWarner instead of the default
 // DCheckAsserter. The method fail_state is used to know if a collision took
 // place.
 class AssertReporter : public base::AsserterBase {
  public:
   AssertReporter()
       : failed_(false) {}
 
-  virtual void warn() OVERRIDE {
-    failed_ = true;
-  }
+  void warn() override { failed_ = true; }
 
   virtual ~AssertReporter() {}
 
   bool fail_state() const { return failed_; }
   void reset() { failed_ = false; }
 
  private:
   bool failed_;
 };
 
@@ skipping 87 matching lines @@
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
     explicit QueueUser(NonThreadSafeQueue& queue)
         : queue_(queue) {}
 
-    virtual void Run() OVERRIDE {
+    void Run() override {
       queue_.push(0);
       queue_.pop();
     }
 
    private:
     NonThreadSafeQueue& queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
@@ skipping 37 matching lines @@
     DFAKE_MUTEX(push_pop_);
 
     DISALLOW_COPY_AND_ASSIGN(NonThreadSafeQueue);
   };
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
     explicit QueueUser(NonThreadSafeQueue& queue)
         : queue_(queue) {}
 
-    virtual void Run() OVERRIDE {
+    void Run() override {
       queue_.push(0);
       queue_.pop();
     }
 
    private:
     NonThreadSafeQueue& queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
@@ skipping 40 matching lines @@
   };
 
   // This time the QueueUser class protects the non thread safe queue with
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
     QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
         : queue_(queue),
           lock_(lock) {}
 
-    virtual void Run() OVERRIDE {
+    void Run() override {
       {
         base::AutoLock auto_lock(lock_);
         queue_.push(0);
       }
       {
         base::AutoLock auto_lock(lock_);
         queue_.pop();
       }
     }
    private:
@@ skipping 53 matching lines @@
   };
 
   // This time the QueueUser class protects the non thread safe queue with
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
     QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
         : queue_(queue),
           lock_(lock) {}
 
-    virtual void Run() OVERRIDE {
+    void Run() override {
       {
         base::AutoLock auto_lock(lock_);
         queue_.push(0);
       }
       {
         base::AutoLock auto_lock(lock_);
         queue_.bar();
       }
       {
         base::AutoLock auto_lock(lock_);
@@ skipping 18 matching lines @@
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
 
   thread_a.Start();
   thread_b.Start();
 
   thread_a.Join();
   thread_b.Join();
 
   EXPECT_FALSE(local_reporter->fail_state());
 }