replace OVERRIDE and FINAL with override and final in net/

net/dns/dns_transaction.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_transaction.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 123 matching lines @@
   DnsUDPAttempt(unsigned server_index,
                 scoped_ptr<DnsSession::SocketLease> socket_lease,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
         received_malformed_response_(false),
         socket_lease_(socket_lease.Pass()),
         query_(query.Pass()) {}
 
   // DnsAttempt:
-  virtual int Start(const CompletionCallback& callback) OVERRIDE {
+  virtual int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_SEND_QUERY;
     return DoLoop(OK);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
+  virtual const DnsQuery* GetQuery() const override {
     return query_.get();
   }
 
-  virtual const DnsResponse* GetResponse() const OVERRIDE {
+  virtual const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
+  virtual const BoundNetLog& GetSocketNetLog() const override {
     return socket_lease_->socket()->NetLog();
   }
 
  private:
   enum State {
     STATE_SEND_QUERY,
     STATE_SEND_QUERY_COMPLETE,
     STATE_READ_RESPONSE,
     STATE_READ_RESPONSE_COMPLETE,
     STATE_NONE,
@@ skipping 127 matching lines @@
                 scoped_ptr<StreamSocket> socket,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
         socket_(socket.Pass()),
         query_(query.Pass()),
         length_buffer_(new IOBufferWithSize(sizeof(uint16))),
         response_length_(0) {}
 
   // DnsAttempt:
-  virtual int Start(const CompletionCallback& callback) OVERRIDE {
+  virtual int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_CONNECT_COMPLETE;
     int rv = socket_->Connect(base::Bind(&DnsTCPAttempt::OnIOComplete,
                                          base::Unretained(this)));
     if (rv == ERR_IO_PENDING) {
       set_result(rv);
       return rv;
     }
     return DoLoop(rv);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
+  virtual const DnsQuery* GetQuery() const override {
     return query_.get();
   }
 
-  virtual const DnsResponse* GetResponse() const OVERRIDE {
+  virtual const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
+  virtual const BoundNetLog& GetSocketNetLog() const override {
     return socket_->NetLog();
   }
 
  private:
   enum State {
     STATE_CONNECT_COMPLETE,
     STATE_SEND_LENGTH,
     STATE_SEND_QUERY,
     STATE_READ_LENGTH,
     STATE_READ_LENGTH_COMPLETE,
@@ skipping 224 matching lines @@
     DCHECK(!IsIPLiteral(hostname_));
   }
 
   virtual ~DnsTransactionImpl() {
     if (!callback_.is_null()) {
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
                                         ERR_ABORTED);
     }  // otherwise logged in DoCallback or Start
   }
 
-  virtual const std::string& GetHostname() const OVERRIDE {
+  virtual const std::string& GetHostname() const override {
     DCHECK(CalledOnValidThread());
     return hostname_;
   }
 
-  virtual uint16 GetType() const OVERRIDE {
+  virtual uint16 GetType() const override {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(!callback_.is_null());
     DCHECK(attempts_.empty());
     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
                         base::Bind(&NetLogStartCallback, &hostname_, qtype_));
     AttemptResult result(PrepareSearch(), NULL);
     if (result.rv == OK) {
       qnames_initial_size_ = qnames_.size();
       if (qtype_ == dns_protocol::kTypeA)
         UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchStart", qnames_.size());
       result = ProcessAttemptResult(StartQuery());
@@ skipping 367 matching lines @@
 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
  public:
   explicit DnsTransactionFactoryImpl(DnsSession* session) {
     session_ = session;
   }
 
   virtual scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16 qtype,
       const CallbackType& callback,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
         session_.get(), hostname, qtype, callback, net_log));
   }
 
  private:
   scoped_refptr<DnsSession> session_;
 };
 
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net