replace OVERRIDE and FINAL with override and 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 42 matching lines @@
 // 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() {}
 
   // StreamSocket implementation:
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return transport_->Connect(callback);
   }
-  virtual void Disconnect() OVERRIDE { transport_->Disconnect(); }
-  virtual bool IsConnected() const OVERRIDE {
+  virtual void Disconnect() override { transport_->Disconnect(); }
+  virtual bool IsConnected() const override {
     return transport_->IsConnected();
   }
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
+  virtual bool IsConnectedAndIdle() const override {
     return transport_->IsConnectedAndIdle();
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return transport_->GetPeerAddress(address);
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return transport_->GetLocalAddress(address);
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return transport_->NetLog();
   }
-  virtual void SetSubresourceSpeculation() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {
     transport_->SetSubresourceSpeculation();
   }
-  virtual void SetOmniboxSpeculation() OVERRIDE {
+  virtual void SetOmniboxSpeculation() override {
     transport_->SetOmniboxSpeculation();
   }
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual bool WasEverUsed() const override {
     return transport_->WasEverUsed();
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override {
     return transport_->UsingTCPFastOpen();
   }
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool WasNpnNegotiated() const override {
     return transport_->WasNpnNegotiated();
   }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return transport_->GetNegotiatedProtocol();
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual 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 {
+                   const CompletionCallback& callback) override {
     return transport_->Read(buf, buf_len, callback);
   }
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return transport_->Write(buf, buf_len, callback);
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
+  virtual int SetReceiveBufferSize(int32 size) override {
     return transport_->SetReceiveBufferSize(size);
   }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
+  virtual 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() {}
 
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   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 109 matching lines @@
 
 // Simulates synchronously receiving an error during Read() or Write()
 class SynchronousErrorStreamSocket : public WrappedStreamSocket {
  public:
   explicit SynchronousErrorStreamSocket(scoped_ptr<StreamSocket> transport);
   virtual ~SynchronousErrorStreamSocket() {}
 
   // 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;
 
   // 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(Error error) {
     DCHECK_GE(0, error);
     have_read_error_ = true;
     pending_read_error_ = error;
   }
@@ skipping 47 matching lines @@
 // 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() {}
 
   // 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;
 
   // 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 192 matching lines @@
  public:
   explicit CountingStreamSocket(scoped_ptr<StreamSocket> transport)
       : WrappedStreamSocket(transport.Pass()),
         read_count_(0),
         write_count_(0) {}
   virtual ~CountingStreamSocket() {}
 
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   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 {
+                    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_;
@@ skipping 28 matching lines @@
   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 {
+                           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 {}
+                            const std::string& cert) override {}
   virtual void DeleteChannelID(const std::string& server_identifier,
                                const base::Closure& completion_callback)
-      OVERRIDE {}
+      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 {}
+      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 {}
+      override {}
+  virtual int GetChannelIDCount() override { return 0; }
+  virtual 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 {
+                           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 {}
+                            const std::string& cert) override {}
   virtual void DeleteChannelID(const std::string& server_identifier,
                                const base::Closure& completion_callback)
-      OVERRIDE {}
+      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 {}
+      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 {}
+      override {}
+  virtual int GetChannelIDCount() override { return 0; }
+  virtual 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 2309 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