replace OVERRIDE and FINAL with override and final in base/

base/observer_list_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/observer_list.h"
 #include "base/observer_list_threadsafe.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/platform_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 class Foo {
  public:
   virtual void Observe(int x) = 0;
   virtual ~Foo() {}
 };
 
 class Adder : public Foo {
  public:
   explicit Adder(int scaler) : total(0), scaler_(scaler) {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     total += x * scaler_;
   }
   virtual ~Adder() {}
   int total;
 
  private:
   int scaler_;
 };
 
 class Disrupter : public Foo {
  public:
   Disrupter(ObserverList<Foo>* list, Foo* doomed)
       : list_(list),
         doomed_(doomed) {
   }
   virtual ~Disrupter() {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     list_->RemoveObserver(doomed_);
   }
 
  private:
   ObserverList<Foo>* list_;
   Foo* doomed_;
 };
 
 class ThreadSafeDisrupter : public Foo {
  public:
   ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed)
       : list_(list),
         doomed_(doomed) {
   }
   virtual ~ThreadSafeDisrupter() {}
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     list_->RemoveObserver(doomed_);
   }
 
  private:
   ObserverListThreadSafe<Foo>* list_;
   Foo* doomed_;
 };
 
 template <typename ObserverListType>
 class AddInObserve : public Foo {
  public:
   explicit AddInObserve(ObserverListType* observer_list)
       : added(false),
         observer_list(observer_list),
         adder(1) {
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     if (!added) {
       added = true;
       observer_list->AddObserver(&adder);
     }
   }
 
   bool added;
   ObserverListType* observer_list;
   Adder adder;
 };
@@ skipping 14 matching lines @@
         start_(Time::Now()),
         count_observes_(0),
         count_addtask_(0),
         do_notifies_(notify),
         weak_factory_(this) {
   }
 
   virtual ~AddRemoveThread() {
   }
 
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     loop_ = new MessageLoop();  // Fire up a message loop.
     loop_->PostTask(
         FROM_HERE,
         base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
     loop_->Run();
     //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
     //    count_observes_ << ", " << count_addtask_;
     delete loop_;
     loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
     delete this;
@@ skipping 20 matching lines @@
 
     loop_->PostTask(
         FROM_HERE,
         base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
   }
 
   void Quit() {
     loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     count_observes_++;
 
     // If we're getting called after we removed ourselves from
     // the list, that is very bad!
     DCHECK(in_list_);
 
     // This callback should fire on the appropriate thread
     EXPECT_EQ(loop_, MessageLoop::current());
 
     list_->RemoveObserver(this);
@@ skipping 155 matching lines @@
 
 class FooRemover : public Foo {
  public:
   explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {}
   virtual ~FooRemover() {}
 
   void AddFooToRemove(Foo* foo) {
     foos_.push_back(foo);
   }
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     std::vector<Foo*> tmp;
     tmp.swap(foos_);
     for (std::vector<Foo*>::iterator it = tmp.begin();
          it != tmp.end(); ++it) {
       list_->RemoveObserver(*it);
     }
   }
 
  private:
   const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
@@ skipping 131 matching lines @@
   observer_list->Notify(&Foo::Observe, 1);
   RunLoop().RunUntilIdle();
   EXPECT_EQ(1, b.adder.total);
 }
 
 class AddInClearObserve : public Foo {
  public:
   explicit AddInClearObserve(ObserverList<Foo>* list)
       : list_(list), added_(false), adder_(1) {}
 
-  virtual void Observe(int /* x */) OVERRIDE {
+  virtual void Observe(int /* x */) override {
     list_->Clear();
     list_->AddObserver(&adder_);
     added_ = true;
   }
 
   bool added() const { return added_; }
   const Adder& adder() const { return adder_; }
 
  private:
   ObserverList<Foo>* const list_;
@@ skipping 24 matching lines @@
   EXPECT_TRUE(a.added());
   EXPECT_EQ(0, a.adder().total)
       << "Adder should not observe, so sum should still be 0.";
 }
 
 class ListDestructor : public Foo {
  public:
   explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {}
   virtual ~ListDestructor() {}
 
-  virtual void Observe(int x) OVERRIDE {
+  virtual void Observe(int x) override {
     delete list_;
   }
 
  private:
   ObserverList<Foo>* list_;
 };
 
 
 TEST(ObserverListTest, IteratorOutlivesList) {
   ObserverList<Foo>* observer_list = new ObserverList<Foo>;
   ListDestructor a(observer_list);
   observer_list->AddObserver(&a);
 
   FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0));
   // If this test fails, there'll be Valgrind errors when this function goes out
   // of scope.
 }
 
 }  // namespace
 }  // namespace base