replace OVERRIDE and FINAL with override and final in base/

base/posix/file_descriptor_shuffle_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/posix/file_descriptor_shuffle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // 'Duplicated' file descriptors start at this number
@@ skipping 26 matching lines @@
   int fd1;
   int fd2;
 };
 
 class InjectionTracer : public InjectionDelegate {
  public:
   InjectionTracer()
       : next_duplicate_(kDuplicateBase) {
   }
 
-  virtual bool Duplicate(int* result, int fd) OVERRIDE {
+  virtual bool Duplicate(int* result, int fd) override {
     *result = next_duplicate_++;
     actions_.push_back(Action(Action::DUPLICATE, *result, fd));
     return true;
   }
 
-  virtual bool Move(int src, int dest) OVERRIDE {
+  virtual bool Move(int src, int dest) override {
     actions_.push_back(Action(Action::MOVE, src, dest));
     return true;
   }
 
-  virtual void Close(int fd) OVERRIDE {
+  virtual void Close(int fd) override {
     actions_.push_back(Action(Action::CLOSE, fd));
   }
 
   const std::vector<Action>& actions() const { return actions_; }
 
  private:
   int next_duplicate_;
   std::vector<Action> actions_;
 };
 
@@ skipping 174 matching lines @@
 
   EXPECT_TRUE(PerformInjectiveMultimap(map, &tracer));
   ASSERT_EQ(3u, tracer.actions().size());
   EXPECT_TRUE(tracer.actions()[0] == Action(Action::MOVE, 0, 1));
   EXPECT_TRUE(tracer.actions()[1] == Action(Action::MOVE, 0, 2));
   EXPECT_TRUE(tracer.actions()[2] == Action(Action::CLOSE, 0));
 }
 
 class FailingDelegate : public InjectionDelegate {
  public:
-  virtual bool Duplicate(int* result, int fd) OVERRIDE {
+  virtual bool Duplicate(int* result, int fd) override {
     return false;
   }
 
-  virtual bool Move(int src, int dest) OVERRIDE {
+  virtual bool Move(int src, int dest) override {
     return false;
   }
 
-  virtual void Close(int fd) OVERRIDE {}
+  virtual void Close(int fd) override {}
 };
 
 TEST(FileDescriptorShuffleTest, EmptyWithFailure) {
   InjectiveMultimap map;
   FailingDelegate failing;
 
   EXPECT_TRUE(PerformInjectiveMultimap(map, &failing));
 }
 
 TEST(FileDescriptorShuffleTest, NoopWithFailure) {
   InjectiveMultimap map;
   FailingDelegate failing;
   map.push_back(InjectionArc(0, 0, false));
 
   EXPECT_TRUE(PerformInjectiveMultimap(map, &failing));
 }
 
 TEST(FileDescriptorShuffleTest, Simple1WithFailure) {
   InjectiveMultimap map;
   FailingDelegate failing;
   map.push_back(InjectionArc(0, 1, false));
 
   EXPECT_FALSE(PerformInjectiveMultimap(map, &failing));
 }
 
 }  // namespace base