replace OVERRIDE and FINAL with override and final in net/

net/socket/transport_client_socket_pool_test_util.cc

 // Copyright 2014 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/socket/transport_client_socket_pool_test_util.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 20 matching lines @@
 // A StreamSocket which connects synchronously and successfully.
 class MockConnectClientSocket : public StreamSocket {
  public:
   MockConnectClientSocket(const AddressList& addrlist, net::NetLog* net_log)
       : connected_(false),
         addrlist_(addrlist),
         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
         use_tcp_fastopen_(false) {}
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     connected_ = true;
     return OK;
   }
-  virtual void Disconnect() OVERRIDE { connected_ = false; }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; }
+  virtual void Disconnect() override { connected_ = false; }
+  virtual bool IsConnected() const override { return connected_; }
+  virtual bool IsConnectedAndIdle() const override { return connected_; }
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     *address = addrlist_.front();
     return OK;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     if (!connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   bool connected_;
   const AddressList addrlist_;
   BoundNetLog net_log_;
   bool use_tcp_fastopen_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectClientSocket);
 };
 
 class MockFailingClientSocket : public StreamSocket {
  public:
   MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log)
       : addrlist_(addrlist),
         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
         use_tcp_fastopen_(false) {}
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return ERR_CONNECTION_FAILED;
   }
 
-  virtual void Disconnect() OVERRIDE {}
+  virtual void Disconnect() override {}
 
-  virtual bool IsConnected() const OVERRIDE { return false; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return false; }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual bool IsConnected() const override { return false; }
+  virtual bool IsConnectedAndIdle() const override { return false; }
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   const AddressList addrlist_;
   BoundNetLog net_log_;
   bool use_tcp_fastopen_;
 
   DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket);
 };
 
 class MockTriggerableClientSocket : public StreamSocket {
@@ skipping 43 matching lines @@
 
   static scoped_ptr<StreamSocket> MakeMockStalledClientSocket(
       const AddressList& addrlist,
       net::NetLog* net_log) {
     scoped_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, true, net_log));
     return socket.PassAs<StreamSocket>();
   }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     DCHECK(callback_.is_null());
     callback_ = callback;
     return ERR_IO_PENDING;
   }
 
-  virtual void Disconnect() OVERRIDE {}
+  virtual void Disconnect() override {}
 
-  virtual bool IsConnected() const OVERRIDE { return is_connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return is_connected_; }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual bool IsConnected() const override { return is_connected_; }
+  virtual bool IsConnectedAndIdle() const override { return is_connected_; }
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     *address = addrlist_.front();
     return OK;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     if (!is_connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   void DoCallback() {
     is_connected_ = should_connect_;
     callback_.Run(is_connected_ ? OK : ERR_CONNECTION_FAILED);
   }
 
   bool should_connect_;
   bool is_connected_;
   const AddressList addrlist_;
@@ skipping 151 matching lines @@
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
   base::Closure trigger = triggerable_sockets_.front();
   triggerable_sockets_.pop();
   return trigger;
 }
 
 }  // namespace net