replace OVERRIDE and FINAL with override and final in net/

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 244 matching lines @@
   size_t write_index() const { return write_index_; }
   size_t read_count() const { return read_count_; }
   size_t write_count() const { return write_count_; }
 
   bool at_read_eof() const { return read_index_ >= read_count_; }
   bool at_write_eof() const { return write_index_ >= write_count_; }
 
   virtual void CompleteRead() {}
 
   // SocketDataProvider implementation.
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
 
  private:
   MockRead* reads_;
   size_t read_index_;
   size_t read_count_;
   MockWrite* writes_;
   size_t write_index_;
   size_t write_count_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSocketDataProvider);
 };
 
 // SocketDataProvider which can make decisions about next mock reads based on
 // received writes. It can also be used to enforce order of operations, for
 // example that tested code must send the "Hello!" message before receiving
 // response. This is useful for testing conversation-like protocols like FTP.
 class DynamicSocketDataProvider : public SocketDataProvider {
  public:
   DynamicSocketDataProvider();
   virtual ~DynamicSocketDataProvider();
 
   int short_read_limit() const { return short_read_limit_; }
   void set_short_read_limit(int limit) { short_read_limit_ = limit; }
 
   void allow_unconsumed_reads(bool allow) { allow_unconsumed_reads_ = allow; }
 
   // SocketDataProvider implementation.
-  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
-  virtual void Reset() OVERRIDE;
+  virtual void Reset() override;
 
  protected:
   // The next time there is a read from this socket, it will return |data|.
   // Before calling SimulateRead next time, the previous data must be consumed.
   void SimulateRead(const char* data, size_t length);
   void SimulateRead(const char* data) { SimulateRead(data, std::strlen(data)); }
 
  private:
   std::deque<MockRead> reads_;
 
@@ skipping 61 matching lines @@
                     int write_delay,
                     MockRead* reads,
                     size_t reads_count,
                     MockWrite* writes,
                     size_t writes_count);
   virtual ~DelayedSocketData();
 
   void ForceNextRead();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override;
 
  private:
   int write_delay_;
   bool read_in_progress_;
 
   base::WeakPtrFactory<DelayedSocketData> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayedSocketData);
 };
 
@@ skipping 30 matching lines @@
   OrderedSocketData(const MockConnect& connect,
                     MockRead* reads,
                     size_t reads_count,
                     MockWrite* writes,
                     size_t writes_count);
 
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override;
 
  private:
   int sequence_number_;
   int loop_stop_stage_;
   bool blocked_;
 
   base::WeakPtrFactory<OrderedSocketData> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OrderedSocketData);
 };
@@ skipping 106 matching lines @@
   void SetStopped(bool val) { stopped_ = val; }
   MockRead& current_read() { return current_read_; }
   MockWrite& current_write() { return current_write_; }
   int sequence_number() const { return sequence_number_; }
   void set_delegate(base::WeakPtr<Delegate> delegate) { delegate_ = delegate; }
 
   // StaticSocketDataProvider:
 
   // When the socket calls Read(), that calls GetNextRead(), and expects either
   // ERR_IO_PENDING or data.
-  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
 
   // When the socket calls Write(), it always completes synchronously. OnWrite()
   // checks to make sure the written data matches the expected data. The
   // callback will not be invoked until its sequence number is reached.
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE {}
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override {}
 
  private:
   // Invoke the read and write callbacks, if the timing is appropriate.
   void InvokeCallbacks();
 
   void NextStep();
 
   void VerifyCorrectSequenceNumbers(MockRead* reads,
                                     size_t reads_count,
                                     MockWrite* writes,
@@ skipping 66 matching lines @@
   // are not necessarily valid.
   const std::vector<MockSSLClientSocket*>& ssl_client_sockets() const {
     return ssl_client_sockets_;
   }
 
   // ClientSocketFactory
   virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE;
-  virtual void ClearSSLSessionCache() OVERRIDE;
+      const SSLClientSocketContext& context) override;
+  virtual void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public SSLClientSocket {
  public:
   // Value returned by GetTLSUniqueChannelBinding().
   static const char kTlsUnique[];
 
   // The BoundNetLog is needed to test LoadTimingInfo, which uses NetLog IDs as
   // unique socket IDs.
   explicit MockClientSocket(const BoundNetLog& net_log);
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
                    const CompletionCallback& callback) = 0;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
                     const CompletionCallback& callback) = 0;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // StreamSocket implementation.
   virtual int Connect(const CompletionCallback& callback) = 0;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
-  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
+  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+      override;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
  protected:
   virtual ~MockClientSocket();
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   // SSLClientSocket implementation.
   virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
-      const OVERRIDE;
+      const override;
 
   // True if Connect completed successfully and Disconnect hasn't been called.
   bool connected_;
 
   // Address of the "remote" peer we're connected to.
   IPEndPoint peer_addr_;
 
   BoundNetLog net_log_;
 
  private:
   base::WeakPtrFactory<MockClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockTCPClientSocket(const AddressList& addresses,
                       net::NetLog* net_log,
                       SocketDataProvider* socket);
   virtual ~MockTCPClientSocket();
 
   const AddressList& addresses() const { return addresses_; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
  private:
   int CompleteRead();
 
   AddressList addresses_;
 
   SocketDataProvider* data_;
   int read_offset_;
   MockRead read_data_;
   bool need_read_data_;
@@ skipping 63 matching lines @@
     : public DatagramClientSocket,
       public AsyncSocket,
       public DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockUDPClientSocket> {
  public:
   DeterministicMockUDPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
   virtual ~DeterministicMockUDPClientSocket();
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const OVERRIDE;
-  virtual bool ReadPending() const OVERRIDE;
-  virtual void CompleteWrite() OVERRIDE;
-  virtual int CompleteRead() OVERRIDE;
+  virtual bool WritePending() const override;
+  virtual bool ReadPending() const override;
+  virtual void CompleteWrite() override;
+  virtual int CompleteRead() override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // DatagramSocket implementation.
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) OVERRIDE;
+  virtual int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
   void set_source_port(int port) { source_port_ = port; }
 
  private:
   bool connected_;
   IPEndPoint peer_address_;
   DeterministicSocketHelper helper_;
   int source_port_;  // Ephemeral source port.
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockUDPClientSocket);
 };
 
 // Mock TCP socket to be used in conjunction with DeterministicSocketData.
 class DeterministicMockTCPClientSocket
     : public MockClientSocket,
       public AsyncSocket,
       public DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
  public:
   DeterministicMockTCPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
   virtual ~DeterministicMockTCPClientSocket();
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const OVERRIDE;
-  virtual bool ReadPending() const OVERRIDE;
-  virtual void CompleteWrite() OVERRIDE;
-  virtual int CompleteRead() OVERRIDE;
+  virtual bool WritePending() const override;
+  virtual bool ReadPending() const override;
+  virtual void CompleteWrite() override;
+  virtual int CompleteRead() override;
 
   // Socket:
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
 
   // StreamSocket:
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
  private:
   DeterministicSocketHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockTCPClientSocket);
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(scoped_ptr<ClientSocketHandle> transport_socket,
                       const HostPortPair& host_and_port,
                       const SSLConfig& ssl_config,
                       SSLSocketDataProvider* socket);
   virtual ~MockSSLClientSocket();
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
-  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
+  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
-  virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
-  virtual void set_protocol_negotiated(NextProto protocol_negotiated) OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
+      override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
+  virtual bool set_was_npn_negotiated(bool negotiated) override;
+  virtual void set_protocol_negotiated(NextProto protocol_negotiated) override;
+  virtual NextProto GetNegotiatedProtocol() const override;
 
   // This MockSocket does not implement the manual async IO feature.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
-  virtual bool WasChannelIDSent() const OVERRIDE;
-  virtual void set_channel_id_sent(bool channel_id_sent) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+  virtual bool WasChannelIDSent() const override;
+  virtual void set_channel_id_sent(bool channel_id_sent) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
   bool reached_connect() const { return reached_connect_; }
 
   // Resumes the connection of a socket that was paused for testing.
   // |connect_callback_| should be set before invoking this method.
   void RestartPausedConnect();
 
  private:
   enum ConnectState {
     STATE_NONE,
@@ skipping 31 matching lines @@
 };
 
 class MockUDPClientSocket : public DatagramClientSocket, public AsyncSocket {
  public:
   MockUDPClientSocket(SocketDataProvider* data, net::NetLog* net_log);
   virtual ~MockUDPClientSocket();
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // DatagramSocket implementation.
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) OVERRIDE;
+  virtual int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
   void set_source_port(int port) { source_port_ = port;}
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
@@ skipping 149 matching lines @@
   }
   int release_count() const { return release_count_; }
   int cancel_count() const { return cancel_count_; }
 
   // TransportClientSocketPool implementation.
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
  private:
   ClientSocketFactory* client_socket_factory_;
   ScopedVector<MockConnectJob> job_list_;
   RequestPriority last_request_priority_;
   int release_count_;
   int cancel_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketPool);
 };
@@ skipping 19 matching lines @@
   }
   std::vector<DeterministicMockUDPClientSocket*>& udp_client_sockets() {
     return udp_client_sockets_;
   }
 
   // ClientSocketFactory
   virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE;
-  virtual void ClearSSLSessionCache() OVERRIDE;
+      const SSLClientSocketContext& context) override;
+  virtual void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<DeterministicSocketData> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<DeterministicMockTCPClientSocket*> tcp_client_sockets_;
   std::vector<DeterministicMockUDPClientSocket*> udp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockClientSocketFactory);
 };
 
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
  public:
   MockSOCKSClientSocketPool(int max_sockets,
                             int max_sockets_per_group,
                             ClientSocketPoolHistograms* histograms,
                             TransportClientSocketPool* transport_pool);
 
   virtual ~MockSOCKSClientSocketPool();
 
   // SOCKSClientSocketPool implementation.
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
  private:
   TransportClientSocketPool* const transport_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSOCKSClientSocketPool);
 };
 
 // Constants for a successful SOCKS v5 handshake.
 extern const char kSOCKS5GreetRequest[];
 extern const int kSOCKS5GreetRequestLength;
 
 extern const char kSOCKS5GreetResponse[];
 extern const int kSOCKS5GreetResponseLength;
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_