Standardize usage of virtual/override/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 225 matching lines @@
 
 // SocketDataProvider which responds based on static tables of mock reads and
 // writes.
 class StaticSocketDataProvider : public SocketDataProvider {
  public:
   StaticSocketDataProvider();
   StaticSocketDataProvider(MockRead* reads,
                            size_t reads_count,
                            MockWrite* writes,
                            size_t writes_count);
-  virtual ~StaticSocketDataProvider();
+  ~StaticSocketDataProvider() override;
 
   // These functions get access to the next available read and write data.
   const MockRead& PeekRead() const;
   const MockWrite& PeekWrite() const;
   // These functions get random access to the read and write data, for timing.
   const MockRead& PeekRead(size_t index) const;
   const MockWrite& PeekWrite(size_t index) const;
   size_t read_index() const { return read_index_; }
   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;
+  MockRead GetNextRead() override;
+  MockWriteResult OnWrite(const std::string& data) override;
+  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();
+  ~DynamicSocketDataProvider() override;
 
   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;
+  MockRead GetNextRead() override;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
-  virtual void Reset() override;
+  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 56 matching lines @@
   //               a MockRead to complete.
   // |writes| the list of MockWrite completions.
   // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
   //       MockRead(true, 0, 0);
   DelayedSocketData(const MockConnect& connect,
                     int write_delay,
                     MockRead* reads,
                     size_t reads_count,
                     MockWrite* writes,
                     size_t writes_count);
-  virtual ~DelayedSocketData();
+  ~DelayedSocketData() override;
 
   void ForceNextRead();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead() override;
-  virtual MockWriteResult OnWrite(const std::string& data) override;
-  virtual void Reset() override;
-  virtual void CompleteRead() override;
+  MockRead GetNextRead() override;
+  MockWriteResult OnWrite(const std::string& data) override;
+  void Reset() override;
+  void CompleteRead() override;
 
  private:
   int write_delay_;
   bool read_in_progress_;
 
   base::WeakPtrFactory<DelayedSocketData> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayedSocketData);
 };
 
@@ skipping 12 matching lines @@
  public:
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
   //       MockRead(true, 0, 0);
   OrderedSocketData(MockRead* reads,
                     size_t reads_count,
                     MockWrite* writes,
                     size_t writes_count);
-  virtual ~OrderedSocketData();
+  ~OrderedSocketData() override;
 
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
   // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
   //       MockRead(true, 0, 0);
   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;
+  MockRead GetNextRead() override;
+  MockWriteResult OnWrite(const std::string& data) override;
+  void Reset() override;
+  void CompleteRead() override;
 
  private:
   int sequence_number_;
   int loop_stop_stage_;
   bool blocked_;
 
   base::WeakPtrFactory<OrderedSocketData> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OrderedSocketData);
 };
@@ skipping 82 matching lines @@
    protected:
     virtual ~Delegate() {}
   };
 
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   DeterministicSocketData(MockRead* reads,
                           size_t reads_count,
                           MockWrite* writes,
                           size_t writes_count);
-  virtual ~DeterministicSocketData();
+  ~DeterministicSocketData() override;
 
   // Consume all the data up to the give stop point (via SetStop()).
   void Run();
 
   // Set the stop point to be |steps| from now, and then invoke Run().
   void RunFor(int steps);
 
   // Stop at step |seq|, which must be in the future.
   virtual void SetStop(int seq);
 
   // Stop |seq| steps after the current step.
   virtual void StopAfter(int seq);
   bool stopped() const { return stopped_; }
   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;
+  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 {}
+  MockWriteResult OnWrite(const std::string& data) override;
+  void Reset() override;
+  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 45 matching lines @@
 class MockSSLClientSocket;
 
 // ClientSocketFactory which contains arrays of sockets of each type.
 // You should first fill the arrays using AddMock{SSL,}Socket. When the factory
 // is asked to create a socket, it takes next entry from appropriate array.
 // You can use ResetNextMockIndexes to reset that next entry index for all mock
 // socket types.
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory();
-  virtual ~MockClientSocketFactory();
+  ~MockClientSocketFactory() override;
 
   void AddSocketDataProvider(SocketDataProvider* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   SocketDataProviderArray<SocketDataProvider>& mock_data() {
     return mock_data_;
   }
 
   // Note: this method is unsafe; the elements of the returned vector
   // are not necessarily valid.
   const std::vector<MockSSLClientSocket*>& ssl_client_sockets() const {
     return ssl_client_sockets_;
   }
 
   // ClientSocketFactory
-  virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
+  scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLog::Source& source) override;
-  virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
+  scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) override;
-  virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
+  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;
+  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;
+  int SetReceiveBufferSize(int32 size) override;
+  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 {}
+  void Disconnect() override;
+  bool IsConnected() const override;
+  bool IsConnectedAndIdle() const override;
+  int GetPeerAddress(IPEndPoint* address) const override;
+  int GetLocalAddress(IPEndPoint* address) const override;
+  const BoundNetLog& NetLog() const override;
+  void SetSubresourceSpeculation() override {}
+  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 void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      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;
+  std::string GetSessionCacheKey() const override;
+  bool InSessionCache() const override;
+  void SetHandshakeCompletionCallback(const base::Closure& cb) override;
+  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
+  int ExportKeyingMaterial(const base::StringPiece& label,
+                           bool has_context,
+                           const base::StringPiece& context,
+                           unsigned char* out,
+                           unsigned int outlen) override;
+  int GetTLSUniqueChannelBinding(std::string* out) override;
+  NextProtoStatus GetNextProto(std::string* proto) override;
+  ChannelIDService* GetChannelIDService() const override;
 
  protected:
-  virtual ~MockClientSocket();
+  ~MockClientSocket() override;
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   // SSLClientSocket implementation.
-  virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
+  scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
       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();
+  ~MockTCPClientSocket() override;
 
   const AddressList& addresses() const { return addresses_; }
 
   // Socket implementation.
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override;
-  virtual int Write(IOBuffer* buf,
-                    int buf_len,
-                    const CompletionCallback& callback) override;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
+  int Write(IOBuffer* buf,
+            int buf_len,
+            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;
+  int Connect(const CompletionCallback& callback) override;
+  void Disconnect() override;
+  bool IsConnected() const override;
+  bool IsConnectedAndIdle() const override;
+  int GetPeerAddress(IPEndPoint* address) const override;
+  bool WasEverUsed() const override;
+  bool UsingTCPFastOpen() const override;
+  bool WasNpnNegotiated() const override;
+  bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) override;
-  virtual void OnConnectComplete(const MockConnect& data) override;
+  void OnReadComplete(const MockRead& data) override;
+  void OnConnectComplete(const MockConnect& data) override;
 
  private:
   int CompleteRead();
 
   AddressList addresses_;
 
   SocketDataProvider* data_;
   int read_offset_;
   MockRead read_data_;
   bool need_read_data_;
@@ skipping 60 matching lines @@
 
 // Mock UDP socket to be used in conjunction with DeterministicSocketData.
 class DeterministicMockUDPClientSocket
     : public DatagramClientSocket,
       public AsyncSocket,
       public DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockUDPClientSocket> {
  public:
   DeterministicMockUDPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
-  virtual ~DeterministicMockUDPClientSocket();
+  ~DeterministicMockUDPClientSocket() override;
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const override;
-  virtual bool ReadPending() const override;
-  virtual void CompleteWrite() override;
-  virtual int CompleteRead() override;
+  bool WritePending() const override;
+  bool ReadPending() const override;
+  void CompleteWrite() override;
+  int CompleteRead() override;
 
   // Socket implementation.
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   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;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override;
+  int SetReceiveBufferSize(int32 size) override;
+  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;
+  void Close() override;
+  int GetPeerAddress(IPEndPoint* address) const override;
+  int GetLocalAddress(IPEndPoint* address) const override;
+  const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) override;
+  int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) override;
-  virtual void OnConnectComplete(const MockConnect& data) override;
+  void OnReadComplete(const MockRead& data) override;
+  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();
+  ~DeterministicMockTCPClientSocket() override;
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const override;
-  virtual bool ReadPending() const override;
-  virtual void CompleteWrite() override;
-  virtual int CompleteRead() override;
+  bool WritePending() const override;
+  bool ReadPending() const override;
+  void CompleteWrite() override;
+  int CompleteRead() override;
 
   // Socket:
-  virtual int Write(IOBuffer* buf,
-                    int buf_len,
-                    const CompletionCallback& callback) override;
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override;
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           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;
+  int Connect(const CompletionCallback& callback) override;
+  void Disconnect() override;
+  bool IsConnected() const override;
+  bool IsConnectedAndIdle() const override;
+  bool WasEverUsed() const override;
+  bool UsingTCPFastOpen() const override;
+  bool WasNpnNegotiated() const override;
+  bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) override;
-  virtual void OnConnectComplete(const MockConnect& data) override;
+  void OnReadComplete(const MockRead& data) override;
+  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();
+  ~MockSSLClientSocket() override;
 
   // Socket implementation.
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override;
-  virtual int Write(IOBuffer* buf,
-                    int buf_len,
-                    const CompletionCallback& callback) override;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
+  int Write(IOBuffer* buf,
+            int buf_len,
+            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;
+  int Connect(const CompletionCallback& callback) override;
+  void Disconnect() override;
+  bool IsConnected() const override;
+  bool WasEverUsed() const override;
+  bool UsingTCPFastOpen() const override;
+  int GetPeerAddress(IPEndPoint* address) const override;
+  bool WasNpnNegotiated() const override;
+  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 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;
+  std::string GetSessionCacheKey() const override;
+  bool InSessionCache() const override;
+  void SetHandshakeCompletionCallback(const base::Closure& cb) override;
+  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
+  NextProtoStatus GetNextProto(std::string* proto) override;
+  bool set_was_npn_negotiated(bool negotiated) override;
+  void set_protocol_negotiated(NextProto protocol_negotiated) override;
+  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;
+  void OnReadComplete(const MockRead& data) override;
+  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;
+  bool WasChannelIDSent() const override;
+  void set_channel_id_sent(bool channel_id_sent) override;
+  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 26 matching lines @@
   base::Closure handshake_completion_callback_;
 
   base::WeakPtrFactory<MockSSLClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSSLClientSocket);
 };
 
 class MockUDPClientSocket : public DatagramClientSocket, public AsyncSocket {
  public:
   MockUDPClientSocket(SocketDataProvider* data, net::NetLog* net_log);
-  virtual ~MockUDPClientSocket();
+  ~MockUDPClientSocket() override;
 
   // Socket implementation.
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   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;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override;
+  int SetReceiveBufferSize(int32 size) override;
+  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;
+  void Close() override;
+  int GetPeerAddress(IPEndPoint* address) const override;
+  int GetLocalAddress(IPEndPoint* address) const override;
+  const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) override;
+  int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) override;
-  virtual void OnConnectComplete(const MockConnect& data) override;
+  void OnReadComplete(const MockRead& data) override;
+  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 15 matching lines @@
 
   base::WeakPtrFactory<MockUDPClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUDPClientSocket);
 };
 
 class TestSocketRequest : public TestCompletionCallbackBase {
  public:
   TestSocketRequest(std::vector<TestSocketRequest*>* request_order,
                     size_t* completion_count);
-  virtual ~TestSocketRequest();
+  ~TestSocketRequest() override;
 
   ClientSocketHandle* handle() { return &handle_; }
 
   const net::CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result);
 
   ClientSocketHandle handle_;
   std::vector<TestSocketRequest*>* request_order_;
@@ skipping 99 matching lines @@
     CompletionCallback user_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(MockConnectJob);
   };
 
   MockTransportClientSocketPool(int max_sockets,
                                 int max_sockets_per_group,
                                 ClientSocketPoolHistograms* histograms,
                                 ClientSocketFactory* socket_factory);
 
-  virtual ~MockTransportClientSocketPool();
+  ~MockTransportClientSocketPool() override;
 
   RequestPriority last_request_priority() const {
     return last_request_priority_;
   }
   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;
+  int RequestSocket(const std::string& group_name,
+                    const void* socket_params,
+                    RequestPriority priority,
+                    ClientSocketHandle* handle,
+                    const CompletionCallback& callback,
+                    const BoundNetLog& net_log) override;
 
-  virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) override;
-  virtual void ReleaseSocket(const std::string& group_name,
-                             scoped_ptr<StreamSocket> socket,
-                             int id) override;
+  void CancelRequest(const std::string& group_name,
+                     ClientSocketHandle* handle) override;
+  void ReleaseSocket(const std::string& group_name,
+                     scoped_ptr<StreamSocket> socket,
+                     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);
 };
 
 class DeterministicMockClientSocketFactory : public ClientSocketFactory {
  public:
   DeterministicMockClientSocketFactory();
-  virtual ~DeterministicMockClientSocketFactory();
+  ~DeterministicMockClientSocketFactory() override;
 
   void AddSocketDataProvider(DeterministicSocketData* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
   // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
   // created.
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
   SocketDataProviderArray<DeterministicSocketData>& mock_data() {
     return mock_data_;
   }
   std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
   std::vector<DeterministicMockUDPClientSocket*>& udp_client_sockets() {
     return udp_client_sockets_;
   }
 
   // ClientSocketFactory
-  virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
+  scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLog::Source& source) override;
-  virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
+  scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) override;
-  virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
+  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;
+  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();
+  ~MockSOCKSClientSocketPool() override;
 
   // 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;
+  int RequestSocket(const std::string& group_name,
+                    const void* socket_params,
+                    RequestPriority priority,
+                    ClientSocketHandle* handle,
+                    const CompletionCallback& callback,
+                    const BoundNetLog& net_log) override;
 
-  virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) override;
-  virtual void ReleaseSocket(const std::string& group_name,
-                             scoped_ptr<StreamSocket> socket,
-                             int id) override;
+  void CancelRequest(const std::string& group_name,
+                     ClientSocketHandle* handle) override;
+  void ReleaseSocket(const std::string& group_name,
+                     scoped_ptr<StreamSocket> socket,
+                     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_