replace OVERRIDE and FINAL with override and final in net/

net/dns/dns_test_util.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 "net/dns/dns_test_util.h"
 
 #include <string>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sys_byteorder.h"
 #include "net/base/dns_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/dns/address_sorter.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 class MockAddressSorter : public AddressSorter {
  public:
   virtual ~MockAddressSorter() {}
   virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
+                    const CallbackType& callback) const override {
     // Do nothing.
     callback.Run(true, list);
   }
 };
 
 // A DnsTransaction which uses MockDnsClientRuleList to determine the response.
 class MockTransaction : public DnsTransaction,
                         public base::SupportsWeakPtr<MockTransaction> {
  public:
   MockTransaction(const MockDnsClientRuleList& rules,
@@ skipping 12 matching lines @@
       if ((rules[i].qtype == qtype) &&
           (hostname.size() >= prefix.size()) &&
           (hostname.compare(0, prefix.size(), prefix) == 0)) {
         result_ = rules[i].result;
         delayed_ = rules[i].delay;
         break;
       }
     }
   }
 
-  virtual const std::string& GetHostname() const OVERRIDE {
+  virtual const std::string& GetHostname() const override {
     return hostname_;
   }
 
-  virtual uint16 GetType() const OVERRIDE {
+  virtual uint16 GetType() const override {
     return qtype_;
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     EXPECT_FALSE(started_);
     started_ = true;
     if (delayed_)
       return;
     // Using WeakPtr to cleanly cancel when transaction is destroyed.
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&MockTransaction::Finish, AsWeakPtr()));
   }
 
   void FinishDelayedTransaction() {
@@ skipping 83 matching lines @@
  public:
   explicit MockTransactionFactory(const MockDnsClientRuleList& rules)
       : rules_(rules) {}
 
   virtual ~MockTransactionFactory() {}
 
   virtual scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16 qtype,
       const DnsTransactionFactory::CallbackType& callback,
-      const BoundNetLog&) OVERRIDE {
+      const BoundNetLog&) override {
     MockTransaction* transaction =
         new MockTransaction(rules_, hostname, qtype, callback);
     if (transaction->delayed())
       delayed_transactions_.push_back(transaction->AsWeakPtr());
     return scoped_ptr<DnsTransaction>(transaction);
   }
 
   void CompleteDelayedTransactions() {
     DelayedTransactionList old_delayed_transactions;
     old_delayed_transactions.swap(delayed_transactions_);
@@ skipping 34 matching lines @@
 
 AddressSorter* MockDnsClient::GetAddressSorter() {
   return address_sorter_.get();
 }
 
 void MockDnsClient::CompleteDelayedTransactions() {
   factory_->CompleteDelayedTransactions();
 }
 
 }  // namespace net