Standardize usage of virtual/override/final in mojo/

mojo/public/cpp/utility/tests/mutex_unittest.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 "mojo/public/cpp/utility/mutex.h"
 
 #include <stdlib.h>  // For |rand()|.
 #include <time.h>  // For |nanosleep()| (defined by POSIX).
 
 #include <vector>
@@ skipping 93 matching lines @@
   MOJO_DISALLOW_COPY_AND_ASSIGN(Fiddler);
 };
 
 class FiddlerThread : public Thread {
  public:
   // Takes ownership of |fiddler|.
   FiddlerThread(Fiddler* fiddler)
       : fiddler_(fiddler) {
   }
 
-  virtual ~FiddlerThread() {
-    delete fiddler_;
-  }
+  ~FiddlerThread() override { delete fiddler_; }
 
-  virtual void Run() override { fiddler_->Fiddle(); }
+  void Run() override { fiddler_->Fiddle(); }
 
  private:
   Fiddler* const fiddler_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FiddlerThread);
 };
 
 // This does a stress test (that also checks exclusion).
 TEST(MutexTest, ThreadedStress) {
   static const size_t kNumThreads = 20;
@@ skipping 31 matching lines @@
 
   // Delete.
   for (size_t i = 0; i < kNumThreads; i++)
     delete fiddler_threads[i];
   fiddler_threads.clear();
 }
 
 class TryThread : public Thread {
  public:
   explicit TryThread(Mutex* mutex) : mutex_(mutex), try_lock_succeeded_() {}
-  virtual ~TryThread() {}
+  ~TryThread() override {}
 
-  virtual void Run() override {
+  void Run() override {
     try_lock_succeeded_ = mutex_->TryLock();
     if (try_lock_succeeded_)
       mutex_->Unlock();
   }
 
   bool try_lock_succeeded() const { return try_lock_succeeded_; }
 
  private:
   Mutex* const mutex_;
   bool try_lock_succeeded_;
@@ skipping 69 matching lines @@
   // Destroy lock with lock held.
   EXPECT_DEATH_IF_SUPPORTED({
     Mutex mutex;
     mutex.Lock();
   }, "");
 }
 #endif  // !defined(NDEBUG)
 
 }  // namespace
 }  // namespace mojo