replace OVERRIDE and FINAL with override and final in net/

net/base/net_log_unittest.cc

 // Copyright (c) 2013 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 "net/base/net_log_unittest.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
@@ skipping 62 matching lines @@
 
 class CountingObserver : public NetLog::ThreadSafeObserver {
  public:
   CountingObserver() : count_(0) {}
 
   virtual ~CountingObserver() {
     if (net_log())
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
+  virtual void OnAddEntry(const NetLog::Entry& entry) override {
     ++count_;
   }
 
   int count() const { return count_; }
 
  private:
   int count_;
 };
 
 class LoggingObserver : public NetLog::ThreadSafeObserver {
  public:
   LoggingObserver() {}
 
   virtual ~LoggingObserver() {
     if (net_log())
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
+  virtual void OnAddEntry(const NetLog::Entry& entry) override {
     base::Value* value = entry.ToValue();
     base::DictionaryValue* dict = NULL;
     ASSERT_TRUE(value->GetAsDictionary(&dict));
     values_.push_back(dict);
   }
 
   size_t GetNumValues() const { return values_.size(); }
   base::DictionaryValue* GetValue(size_t index) const { return values_[index]; }
 
  private:
@@ skipping 18 matching lines @@
         start_event_(NULL) {
   }
 
   // We'll wait for |start_event| to be triggered before calling a subclass's
   // subclass's RunTestThread() function.
   void Init(NetLog* net_log, base::WaitableEvent* start_event) {
     start_event_ = start_event;
     net_log_ = net_log;
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     start_event_->Wait();
     RunTestThread();
   }
 
   // Subclasses must override this with the code they want to run on their
   // thread.
   virtual void RunTestThread() = 0;
 
  protected:
   NetLog* net_log_;
 
  private:
   // Only triggered once all threads have been created, to make it less likely
   // each thread completes before the next one starts.
   base::WaitableEvent* start_event_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogTestThread);
 };
 
 // A thread that adds a bunch of events to the NetLog.
 class AddEventsTestThread : public NetLogTestThread {
  public:
   AddEventsTestThread() {}
   virtual ~AddEventsTestThread() {}
 
  private:
-  virtual void RunTestThread() OVERRIDE {
+  virtual void RunTestThread() override {
     for (int i = 0; i < kEvents; ++i)
       AddEvent(net_log_);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
 };
 
 // A thread that adds and removes an observer from the NetLog repeatedly.
 class AddRemoveObserverTestThread : public NetLogTestThread {
  public:
   AddRemoveObserverTestThread() {}
 
   virtual ~AddRemoveObserverTestThread() {
     EXPECT_TRUE(!observer_.net_log());
   }
 
  private:
-  virtual void RunTestThread() OVERRIDE {
+  virtual void RunTestThread() override {
     for (int i = 0; i < kEvents; ++i) {
       ASSERT_FALSE(observer_.net_log());
 
       net_log_->AddThreadSafeObserver(&observer_, NetLog::LOG_ALL_BUT_BYTES);
       ASSERT_EQ(net_log_, observer_.net_log());
       ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
       ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES);
 
       net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL);
       ASSERT_EQ(net_log_, observer_.net_log());
@@ skipping 155 matching lines @@
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net