replace OVERRIDE and FINAL with override and final in base/

base/tools_sanity_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.
 //
 // This file contains intentional memory errors, some of which may lead to
 // crashes if the test is ran without special memory testing tools. We use these
 // errors to verify the sanity of the tools.
 
 #include "base/atomicops.h"
 #include "base/debug/asan_invalid_access.h"
@@ skipping 221 matching lines @@
 #endif  // ADDRESS_SANITIZER || SYZYASAN
 
 namespace {
 
 // We use caps here just to ensure that the method name doesn't interfere with
 // the wildcarded suppressions.
 class TOOLS_SANITY_TEST_CONCURRENT_THREAD : public PlatformThread::Delegate {
  public:
   explicit TOOLS_SANITY_TEST_CONCURRENT_THREAD(bool *value) : value_(value) {}
   virtual ~TOOLS_SANITY_TEST_CONCURRENT_THREAD() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     *value_ = true;
 
     // Sleep for a few milliseconds so the two threads are more likely to live
     // simultaneously. Otherwise we may miss the report due to mutex
     // lock/unlock's inside thread creation code in pure-happens-before mode...
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   }
  private:
   bool *value_;
 };
 
 class ReleaseStoreThread : public PlatformThread::Delegate {
  public:
   explicit ReleaseStoreThread(base::subtle::Atomic32 *value) : value_(value) {}
   virtual ~ReleaseStoreThread() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     base::subtle::Release_Store(value_, kMagicValue);
 
     // Sleep for a few milliseconds so the two threads are more likely to live
     // simultaneously. Otherwise we may miss the report due to mutex
     // lock/unlock's inside thread creation code in pure-happens-before mode...
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
   }
  private:
   base::subtle::Atomic32 *value_;
 };
 
 class AcquireLoadThread : public PlatformThread::Delegate {
  public:
   explicit AcquireLoadThread(base::subtle::Atomic32 *value) : value_(value) {}
   virtual ~AcquireLoadThread() {}
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     // Wait for the other thread to make Release_Store
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
     base::subtle::Acquire_Load(value_);
   }
  private:
   base::subtle::Atomic32 *value_;
 };
 
 void RunInParallel(PlatformThread::Delegate *d1, PlatformThread::Delegate *d2) {
   PlatformThreadHandle a;
@@ skipping 36 matching lines @@
 
 TEST(ToolsSanityTest, AtomicsAreIgnored) {
   base::subtle::Atomic32 shared = 0;
   ReleaseStoreThread thread1(&shared);
   AcquireLoadThread thread2(&shared);
   RunInParallel(&thread1, &thread2);
   EXPECT_EQ(kMagicValue, shared);
 }
 
 }  // namespace base