replace OVERRIDE and FINAL with override and final in net/

net/socket/client_socket_pool_base_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/client_socket_pool_base.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 112 matching lines @@
 
   // Sets whether the socket has unread data. If true, the next call to Read()
   // will return 1 byte and IsConnectedAndIdle() will return false.
   void set_has_unread_data(bool has_unread_data) {
     has_unread_data_ = has_unread_data;
   }
 
   // Socket implementation.
   virtual int Read(
       IOBuffer* /* buf */, int len,
-      const CompletionCallback& /* callback */) OVERRIDE {
+      const CompletionCallback& /* callback */) override {
     if (has_unread_data_ && len > 0) {
       has_unread_data_ = false;
       was_used_to_convey_data_ = true;
       return 1;
     }
     return ERR_UNEXPECTED;
   }
 
   virtual int Write(
       IOBuffer* /* buf */, int len,
-      const CompletionCallback& /* callback */) OVERRIDE {
+      const CompletionCallback& /* callback */) override {
     was_used_to_convey_data_ = true;
     return len;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     connected_ = true;
     return OK;
   }
 
-  virtual void Disconnect() OVERRIDE { connected_ = false; }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
+  virtual void Disconnect() override { connected_ = false; }
+  virtual bool IsConnected() const override { return connected_; }
+  virtual bool IsConnectedAndIdle() const override {
     return connected_ && !has_unread_data_;
   }
 
-  virtual int GetPeerAddress(IPEndPoint* /* address */) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* /* address */) const override {
     return ERR_UNEXPECTED;
   }
 
-  virtual int GetLocalAddress(IPEndPoint* /* address */) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* /* address */) const override {
     return ERR_UNEXPECTED;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override {
     return was_used_to_convey_data_;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return false; }
+  virtual bool WasNpnNegotiated() const override {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
     return false;
   }
 
  private:
   bool connected_;
   bool has_unread_data_;
   BoundNetLog net_log_;
   bool was_used_to_convey_data_;
 
   DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 };
 
 class TestConnectJob;
 
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory() : allocation_count_(0) {}
 
   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 {
     NOTREACHED();
     return scoped_ptr<DatagramClientSocket>();
   }
 
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
-      const NetLog::Source& /*source*/) OVERRIDE {
+      const NetLog::Source& /*source*/) override {
     allocation_count_++;
     return scoped_ptr<StreamSocket>();
   }
 
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE {
+      const SSLClientSocketContext& context) override {
     NOTIMPLEMENTED();
     return scoped_ptr<SSLClientSocket>();
   }
 
-  virtual void ClearSSLSessionCache() OVERRIDE {
+  virtual void ClearSSLSessionCache() override {
     NOTIMPLEMENTED();
   }
 
   void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
 
   void SignalJobs();
 
   void SignalJob(size_t job);
 
   void SetJobLoadState(size_t job, LoadState load_state);
@@ skipping 41 matching lines @@
   }
 
   void Signal() {
     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
   }
 
   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 
   // From ConnectJob:
 
-  virtual LoadState GetLoadState() const OVERRIDE { return load_state_; }
+  virtual LoadState GetLoadState() const override { return load_state_; }
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE {
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) override {
     if (store_additional_error_state_) {
       // Set all of the additional error state fields in some way.
       handle->set_is_ssl_error(true);
       HttpResponseInfo info;
       info.headers = new HttpResponseHeaders(std::string());
       handle->set_ssl_error_response_info(info);
     }
   }
 
  private:
   // From ConnectJob:
 
-  virtual int ConnectInternal() OVERRIDE {
+  virtual int ConnectInternal() override {
     AddressList ignored;
     client_socket_factory_->CreateTransportClientSocket(
         ignored, NULL, net::NetLog::Source());
     SetSocket(
         scoped_ptr<StreamSocket>(new MockClientSocket(net_log().net_log())));
     switch (job_type_) {
       case kMockJob:
         return DoConnect(true /* successful */, false /* sync */,
                          false /* recoverable */);
       case kMockFailingJob:
@@ skipping 130 matching lines @@
 
   void set_timeout_duration(base::TimeDelta timeout_duration) {
     timeout_duration_ = timeout_duration;
   }
 
   // ConnectJobFactory implementation.
 
   virtual scoped_ptr<ConnectJob> NewConnectJob(
       const std::string& group_name,
       const TestClientSocketPoolBase::Request& request,
-      ConnectJob::Delegate* delegate) const OVERRIDE {
+      ConnectJob::Delegate* delegate) const override {
     EXPECT_TRUE(!job_types_ || !job_types_->empty());
     TestConnectJob::JobType job_type = job_type_;
     if (job_types_ && !job_types_->empty()) {
       job_type = job_types_->front();
       job_types_->pop_front();
     }
     return scoped_ptr<ConnectJob>(new TestConnectJob(job_type,
                                                      group_name,
                                                      request,
                                                      timeout_duration_,
                                                      delegate,
                                                      client_socket_factory_,
                                                      net_log_));
   }
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+  virtual base::TimeDelta ConnectionTimeout() const override {
     return timeout_duration_;
   }
 
  private:
   TestConnectJob::JobType job_type_;
   std::list<TestConnectJob::JobType>* job_types_;
   base::TimeDelta timeout_duration_;
   MockClientSocketFactory* const client_socket_factory_;
   NetLog* net_log_;
 
@@ skipping 16 matching lines @@
               connect_job_factory) {}
 
   virtual ~TestClientSocketPool() {}
 
   virtual int RequestSocket(
       const std::string& group_name,
       const void* params,
       net::RequestPriority priority,
       ClientSocketHandle* handle,
       const CompletionCallback& callback,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_socket_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
     return base_.RequestSocket(group_name, *casted_socket_params, priority,
                                handle, callback, net_log);
   }
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE {
+                              const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 
     base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
   }
 
   virtual void CancelRequest(
       const std::string& group_name,
-      ClientSocketHandle* handle) OVERRIDE {
+      ClientSocketHandle* handle) override {
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
       scoped_ptr<StreamSocket> socket,
-      int id) OVERRIDE {
+      int id) override {
     base_.ReleaseSocket(group_name, socket.Pass(), id);
   }
 
-  virtual void FlushWithError(int error) OVERRIDE {
+  virtual void FlushWithError(int error) override {
     base_.FlushWithError(error);
   }
 
-  virtual bool IsStalled() const OVERRIDE {
+  virtual bool IsStalled() const override {
     return base_.IsStalled();
   }
 
-  virtual void CloseIdleSockets() OVERRIDE {
+  virtual void CloseIdleSockets() override {
     base_.CloseIdleSockets();
   }
 
-  virtual int IdleSocketCount() const OVERRIDE {
+  virtual int IdleSocketCount() const override {
     return base_.idle_socket_count();
   }
 
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE {
+      const std::string& group_name) const override {
     return base_.IdleSocketCountInGroup(group_name);
   }
 
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE {
+      const ClientSocketHandle* handle) const override {
     return base_.GetLoadState(group_name, handle);
   }
 
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE {
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override {
     base_.AddHigherLayeredPool(higher_pool);
   }
 
   virtual void RemoveHigherLayeredPool(
-      HigherLayeredPool* higher_pool) OVERRIDE {
+      HigherLayeredPool* higher_pool) override {
     base_.RemoveHigherLayeredPool(higher_pool);
   }
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE {
+      bool include_nested_pools) const override {
     return base_.GetInfoAsValue(name, type);
   }
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+  virtual base::TimeDelta ConnectionTimeout() const override {
     return base_.ConnectionTimeout();
   }
 
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE {
+  virtual ClientSocketPoolHistograms* histograms() const override {
     return base_.histograms();
   }
 
   const TestClientSocketPoolBase* base() const { return &base_; }
 
   int NumUnassignedConnectJobsInGroup(const std::string& group_name) const {
     return base_.NumUnassignedConnectJobsInGroup(group_name);
   }
 
   int NumConnectJobsInGroup(const std::string& group_name) const {
@@ skipping 45 matching lines @@
   ASSERT_LT(job, waiting_jobs_.size());
   waiting_jobs_[job]->set_load_state(load_state);
 }
 
 class TestConnectJobDelegate : public ConnectJob::Delegate {
  public:
   TestConnectJobDelegate()
       : have_result_(false), waiting_for_result_(false), result_(OK) {}
   virtual ~TestConnectJobDelegate() {}
 
-  virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE {
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) override {
     result_ = result;
     scoped_ptr<ConnectJob> owned_job(job);
     scoped_ptr<StreamSocket> socket = owned_job->PassSocket();
     // socket.get() should be NULL iff result != OK
     EXPECT_EQ(socket == NULL, result != OK);
     have_result_ = true;
     if (waiting_for_result_)
       base::MessageLoop::current()->Quit();
   }
 
@@ skipping 3453 matching lines @@
   request(1)->handle()->Reset();
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_EQ(OK, request(2)->WaitForResult());
   EXPECT_FALSE(request(1)->have_result());
 }
 
 }  // namespace
 
 }  // namespace net