Standardize usage of virtual/override/final in net/

net/socket/ssl_client_socket_unittest.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/socket/ssl_client_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
@@ skipping 39 matching lines @@
 // WrappedStreamSocket is a base class that wraps an existing StreamSocket,
 // forwarding the Socket and StreamSocket interfaces to the underlying
 // transport.
 // This is to provide a common base class for subclasses to override specific
 // StreamSocket methods for testing, while still communicating with a 'real'
 // StreamSocket.
 class WrappedStreamSocket : public StreamSocket {
  public:
   explicit WrappedStreamSocket(scoped_ptr<StreamSocket> transport)
       : transport_(transport.Pass()) {}
-  virtual ~WrappedStreamSocket() {}
+  ~WrappedStreamSocket() override {}
 
   // StreamSocket implementation:
-  virtual int Connect(const CompletionCallback& callback) override {
+  int Connect(const CompletionCallback& callback) override {
     return transport_->Connect(callback);
   }
-  virtual void Disconnect() override { transport_->Disconnect(); }
-  virtual bool IsConnected() const override {
-    return transport_->IsConnected();
-  }
-  virtual bool IsConnectedAndIdle() const override {
+  void Disconnect() override { transport_->Disconnect(); }
+  bool IsConnected() const override { return transport_->IsConnected(); }
+  bool IsConnectedAndIdle() const override {
     return transport_->IsConnectedAndIdle();
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const override {
+  int GetPeerAddress(IPEndPoint* address) const override {
     return transport_->GetPeerAddress(address);
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const override {
+  int GetLocalAddress(IPEndPoint* address) const override {
     return transport_->GetLocalAddress(address);
   }
-  virtual const BoundNetLog& NetLog() const override {
-    return transport_->NetLog();
-  }
-  virtual void SetSubresourceSpeculation() override {
+  const BoundNetLog& NetLog() const override { return transport_->NetLog(); }
+  void SetSubresourceSpeculation() override {
     transport_->SetSubresourceSpeculation();
   }
-  virtual void SetOmniboxSpeculation() override {
-    transport_->SetOmniboxSpeculation();
-  }
-  virtual bool WasEverUsed() const override {
-    return transport_->WasEverUsed();
-  }
-  virtual bool UsingTCPFastOpen() const override {
+  void SetOmniboxSpeculation() override { transport_->SetOmniboxSpeculation(); }
+  bool WasEverUsed() const override { return transport_->WasEverUsed(); }
+  bool UsingTCPFastOpen() const override {
     return transport_->UsingTCPFastOpen();
   }
-  virtual bool WasNpnNegotiated() const override {
+  bool WasNpnNegotiated() const override {
     return transport_->WasNpnNegotiated();
   }
-  virtual NextProto GetNegotiatedProtocol() const override {
+  NextProto GetNegotiatedProtocol() const override {
     return transport_->GetNegotiatedProtocol();
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
+  bool GetSSLInfo(SSLInfo* ssl_info) override {
     return transport_->GetSSLInfo(ssl_info);
   }
 
   // Socket implementation:
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override {
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override {
     return transport_->Read(buf, buf_len, callback);
   }
-  virtual int Write(IOBuffer* buf,
-                    int buf_len,
-                    const CompletionCallback& callback) override {
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override {
     return transport_->Write(buf, buf_len, callback);
   }
-  virtual int SetReceiveBufferSize(int32 size) override {
+  int SetReceiveBufferSize(int32 size) override {
     return transport_->SetReceiveBufferSize(size);
   }
-  virtual int SetSendBufferSize(int32 size) override {
+  int SetSendBufferSize(int32 size) override {
     return transport_->SetSendBufferSize(size);
   }
 
  protected:
   scoped_ptr<StreamSocket> transport_;
 };
 
 // ReadBufferingStreamSocket is a wrapper for an existing StreamSocket that
 // will ensure a certain amount of data is internally buffered before
 // satisfying a Read() request. It exists to mimic OS-level internal
 // buffering, but in a way to guarantee that X number of bytes will be
 // returned to callers of Read(), regardless of how quickly the OS receives
 // them from the TestServer.
 class ReadBufferingStreamSocket : public WrappedStreamSocket {
  public:
   explicit ReadBufferingStreamSocket(scoped_ptr<StreamSocket> transport);
-  virtual ~ReadBufferingStreamSocket() {}
+  ~ReadBufferingStreamSocket() override {}
 
   // Socket implementation:
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override;
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override;
 
   // Sets the internal buffer to |size|. This must not be greater than
   // the largest value supplied to Read() - that is, it does not handle
   // having "leftovers" at the end of Read().
   // Each call to Read() will be prevented from completion until at least
   // |size| data has been read.
   // Set to 0 to turn off buffering, causing Read() to transparently
   // read via the underlying transport.
   void SetBufferSize(int size);
 
@@ skipping 104 matching lines @@
     return;
 
   user_read_buf_ = NULL;
   base::ResetAndReturn(&user_read_callback_).Run(result);
 }
 
 // Simulates synchronously receiving an error during Read() or Write()
 class SynchronousErrorStreamSocket : public WrappedStreamSocket {
  public:
   explicit SynchronousErrorStreamSocket(scoped_ptr<StreamSocket> transport);
-  virtual ~SynchronousErrorStreamSocket() {}
+  ~SynchronousErrorStreamSocket() 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;
 
   // Sets the next Read() call and all future calls to return |error|.
   // If there is already a pending asynchronous read, the configured error
   // will not be returned until that asynchronous read has completed and Read()
   // is called again.
   void SetNextReadError(int error) {
     DCHECK_GE(0, error);
     have_read_error_ = true;
     pending_read_error_ = error;
   }
@@ skipping 42 matching lines @@
   return transport_->Write(buf, buf_len, callback);
 }
 
 // FakeBlockingStreamSocket wraps an existing StreamSocket and simulates the
 // underlying transport needing to complete things asynchronously in a
 // deterministic manner (e.g.: independent of the TestServer and the OS's
 // semantics).
 class FakeBlockingStreamSocket : public WrappedStreamSocket {
  public:
   explicit FakeBlockingStreamSocket(scoped_ptr<StreamSocket> transport);
-  virtual ~FakeBlockingStreamSocket() {}
+  ~FakeBlockingStreamSocket() 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;
 
   // Blocks read results on the socket. Reads will not complete until
   // UnblockReadResult() has been called and a result is ready from the
   // underlying transport. Note: if BlockReadResult() is called while there is a
   // hanging asynchronous Read(), that Read is blocked.
   void BlockReadResult();
   void UnblockReadResult();
 
   // Waits for the blocked Read() call to be complete at the underlying
   // transport.
@@ skipping 187 matching lines @@
 }
 
 // CountingStreamSocket wraps an existing StreamSocket and maintains a count of
 // reads and writes on the socket.
 class CountingStreamSocket : public WrappedStreamSocket {
  public:
   explicit CountingStreamSocket(scoped_ptr<StreamSocket> transport)
       : WrappedStreamSocket(transport.Pass()),
         read_count_(0),
         write_count_(0) {}
-  virtual ~CountingStreamSocket() {}
+  ~CountingStreamSocket() override {}
 
   // Socket implementation:
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
-                   const CompletionCallback& callback) override {
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override {
     read_count_++;
     return transport_->Read(buf, buf_len, callback);
   }
-  virtual int Write(IOBuffer* buf,
-                    int buf_len,
-                    const CompletionCallback& callback) override {
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override {
     write_count_++;
     return transport_->Write(buf, buf_len, callback);
   }
 
   int read_count() const { return read_count_; }
   int write_count() const { return write_count_; }
 
  private:
   int read_count_;
   int write_count_;
 };
 
 // CompletionCallback that will delete the associated StreamSocket when
 // the callback is invoked.
 class DeleteSocketCallback : public TestCompletionCallbackBase {
  public:
   explicit DeleteSocketCallback(StreamSocket* socket)
       : socket_(socket),
         callback_(base::Bind(&DeleteSocketCallback::OnComplete,
                              base::Unretained(this))) {}
-  virtual ~DeleteSocketCallback() {}
+  ~DeleteSocketCallback() override {}
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void OnComplete(int result) {
     if (socket_) {
       delete socket_;
       socket_ = NULL;
     } else {
       ADD_FAILURE() << "Deleting socket twice";
     }
     SetResult(result);
   }
 
   StreamSocket* socket_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteSocketCallback);
 };
 
 // A ChannelIDStore that always returns an error when asked for a
 // channel id.
 class FailingChannelIDStore : public ChannelIDStore {
-  virtual int GetChannelID(const std::string& server_identifier,
-                           base::Time* expiration_time,
-                           std::string* private_key_result,
-                           std::string* cert_result,
-                           const GetChannelIDCallback& callback) override {
+  int GetChannelID(const std::string& server_identifier,
+                   base::Time* expiration_time,
+                   std::string* private_key_result,
+                   std::string* cert_result,
+                   const GetChannelIDCallback& callback) override {
     return ERR_UNEXPECTED;
   }
-  virtual void SetChannelID(const std::string& server_identifier,
-                            base::Time creation_time,
-                            base::Time expiration_time,
-                            const std::string& private_key,
-                            const std::string& cert) override {}
-  virtual void DeleteChannelID(const std::string& server_identifier,
-                               const base::Closure& completion_callback)
-      override {}
-  virtual void DeleteAllCreatedBetween(base::Time delete_begin,
-                                       base::Time delete_end,
-                                       const base::Closure& completion_callback)
-      override {}
-  virtual void DeleteAll(const base::Closure& completion_callback) override {}
-  virtual void GetAllChannelIDs(const GetChannelIDListCallback& callback)
-      override {}
-  virtual int GetChannelIDCount() override { return 0; }
-  virtual void SetForceKeepSessionState() override {}
+  void SetChannelID(const std::string& server_identifier,
+                    base::Time creation_time,
+                    base::Time expiration_time,
+                    const std::string& private_key,
+                    const std::string& cert) override {}
+  void DeleteChannelID(const std::string& server_identifier,
+                       const base::Closure& completion_callback) override {}
+  void DeleteAllCreatedBetween(
+      base::Time delete_begin,
+      base::Time delete_end,
+      const base::Closure& completion_callback) override {}
+  void DeleteAll(const base::Closure& completion_callback) override {}
+  void GetAllChannelIDs(const GetChannelIDListCallback& callback) override {}
+  int GetChannelIDCount() override { return 0; }
+  void SetForceKeepSessionState() override {}
 };
 
 // A ChannelIDStore that asynchronously returns an error when asked for a
 // channel id.
 class AsyncFailingChannelIDStore : public ChannelIDStore {
-  virtual int GetChannelID(const std::string& server_identifier,
-                           base::Time* expiration_time,
-                           std::string* private_key_result,
-                           std::string* cert_result,
-                           const GetChannelIDCallback& callback) override {
+  int GetChannelID(const std::string& server_identifier,
+                   base::Time* expiration_time,
+                   std::string* private_key_result,
+                   std::string* cert_result,
+                   const GetChannelIDCallback& callback) override {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERR_UNEXPECTED,
                               server_identifier, base::Time(), "", ""));
     return ERR_IO_PENDING;
   }
-  virtual void SetChannelID(const std::string& server_identifier,
-                            base::Time creation_time,
-                            base::Time expiration_time,
-                            const std::string& private_key,
-                            const std::string& cert) override {}
-  virtual void DeleteChannelID(const std::string& server_identifier,
-                               const base::Closure& completion_callback)
-      override {}
-  virtual void DeleteAllCreatedBetween(base::Time delete_begin,
-                                       base::Time delete_end,
-                                       const base::Closure& completion_callback)
-      override {}
-  virtual void DeleteAll(const base::Closure& completion_callback) override {}
-  virtual void GetAllChannelIDs(const GetChannelIDListCallback& callback)
-      override {}
-  virtual int GetChannelIDCount() override { return 0; }
-  virtual void SetForceKeepSessionState() override {}
+  void SetChannelID(const std::string& server_identifier,
+                    base::Time creation_time,
+                    base::Time expiration_time,
+                    const std::string& private_key,
+                    const std::string& cert) override {}
+  void DeleteChannelID(const std::string& server_identifier,
+                       const base::Closure& completion_callback) override {}
+  void DeleteAllCreatedBetween(
+      base::Time delete_begin,
+      base::Time delete_end,
+      const base::Closure& completion_callback) override {}
+  void DeleteAll(const base::Closure& completion_callback) override {}
+  void GetAllChannelIDs(const GetChannelIDListCallback& callback) override {}
+  int GetChannelIDCount() override { return 0; }
+  void SetForceKeepSessionState() override {}
 };
 
 // A mock CTVerifier that records every call to Verify but doesn't verify
 // anything.
 class MockCTVerifier : public CTVerifier {
  public:
   MOCK_METHOD5(Verify, int(X509Certificate*,
                            const std::string&,
                            const std::string&,
                            ct::CTVerifyResult*,
@@ skipping 2363 matching lines @@
   ssl_config.channel_id_enabled = true;
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(ERR_UNEXPECTED, rv);
   EXPECT_FALSE(sock_->IsConnected());
 }
 
 }  // namespace net