replace OVERRIDE and FINAL with override and final in net/

net/dns/host_resolver_impl.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/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 1406 matching lines @@
     }
   }
 
   AddressList MakeAddressListForRequest(const AddressList& list) const {
     if (requests_.empty())
       return list;
     return AddressList::CopyWithPort(list, requests_.front()->info().port());
   }
 
   // PriorityDispatch::Job:
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK_LE(num_occupied_job_slots_, 1u);
 
     handle_.Reset();
     ++num_occupied_job_slots_;
 
     if (num_occupied_job_slots_ == 2) {
       StartSecondDnsTransaction();
       return;
     }
 
@@ skipping 145 matching lines @@
       CompleteRequestsWithError(net_error);
     }
   }
 
 
   // HostResolverImpl::DnsTask::Delegate implementation:
 
   virtual void OnDnsTaskComplete(base::TimeTicks start_time,
                                  int net_error,
                                  const AddressList& addr_list,
-                                 base::TimeDelta ttl) OVERRIDE {
+                                 base::TimeDelta ttl) override {
     DCHECK(is_dns_running());
 
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
     if (net_error != OK) {
       OnDnsTaskFailure(dns_task_->AsWeakPtr(), duration, net_error);
       return;
     }
     DNS_HISTOGRAM("AsyncDNS.ResolveSuccess", duration);
     // Log DNS lookups based on |address_family|.
     switch(key_.address_family) {
@@ skipping 14 matching lines @@
     resolver_->OnDnsTaskResolve(OK);
 
     base::TimeDelta bounded_ttl =
         std::max(ttl, base::TimeDelta::FromSeconds(kMinimumTTLSeconds));
 
     CompleteRequests(
         HostCache::Entry(net_error, MakeAddressListForRequest(addr_list), ttl),
         bounded_ttl);
   }
 
-  virtual void OnFirstDnsTransactionComplete() OVERRIDE {
+  virtual void OnFirstDnsTransactionComplete() override {
     DCHECK(dns_task_->needs_two_transactions());
     DCHECK_EQ(dns_task_->needs_another_transaction(), is_queued());
     // No longer need to occupy two dispatcher slots.
     ReduceToOneJobSlot();
 
     // We already have a job slot at the dispatcher, so if the second
     // transaction hasn't started, reuse it now instead of waiting in the queue
     // for the second slot.
     if (dns_task_->needs_another_transaction())
       dns_task_->StartSecondTransaction();
@@ skipping 720 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net