Standardize usage of virtual/override/final in net/

net/server/http_server_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 171 matching lines @@
   HttpServerTest() : quit_after_request_count_(0) {}
 
   virtual void SetUp() override {
     scoped_ptr<ServerSocket> server_socket(
         new TCPServerSocket(NULL, net::NetLog::Source()));
     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
     server_.reset(new HttpServer(server_socket.Pass(), this));
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
-  virtual void OnConnect(int connection_id) override {}
+  void OnConnect(int connection_id) override {}
 
-  virtual void OnHttpRequest(int connection_id,
-                             const HttpServerRequestInfo& info) override {
+  void OnHttpRequest(int connection_id,
+                     const HttpServerRequestInfo& info) override {
     requests_.push_back(std::make_pair(info, connection_id));
     if (requests_.size() == quit_after_request_count_)
       run_loop_quit_func_.Run();
   }
 
-  virtual void OnWebSocketRequest(int connection_id,
-                                  const HttpServerRequestInfo& info) override {
+  void OnWebSocketRequest(int connection_id,
+                          const HttpServerRequestInfo& info) override {
     NOTREACHED();
   }
 
-  virtual void OnWebSocketMessage(int connection_id,
-                                  const std::string& data) override {
+  void OnWebSocketMessage(int connection_id, const std::string& data) override {
     NOTREACHED();
   }
 
-  virtual void OnClose(int connection_id) override {}
+  void OnClose(int connection_id) override {}
 
   bool RunUntilRequestsReceived(size_t count) {
     quit_after_request_count_ = count;
     if (requests_.size() == count)
       return true;
 
     base::RunLoop run_loop;
     run_loop_quit_func_ = run_loop.QuitClosure();
     bool success = RunLoopWithTimeout(&run_loop);
     run_loop_quit_func_.Reset();
@@ skipping 19 matching lines @@
   base::Closure run_loop_quit_func_;
   std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
 
  private:
   size_t quit_after_request_count_;
 };
 
 namespace {
 
 class WebSocketTest : public HttpServerTest {
-  virtual void OnHttpRequest(int connection_id,
-                             const HttpServerRequestInfo& info) override {
+  void OnHttpRequest(int connection_id,
+                     const HttpServerRequestInfo& info) override {
     NOTREACHED();
   }
 
-  virtual void OnWebSocketRequest(int connection_id,
-                                  const HttpServerRequestInfo& info) override {
+  void OnWebSocketRequest(int connection_id,
+                          const HttpServerRequestInfo& info) override {
     HttpServerTest::OnHttpRequest(connection_id, info);
   }
 
-  virtual void OnWebSocketMessage(int connection_id,
-                                  const std::string& data) override {
+  void OnWebSocketMessage(int connection_id, const std::string& data) override {
   }
 };
 
 TEST_F(HttpServerTest, Request) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("GET", GetRequest(0).method);
   ASSERT_EQ("/test", GetRequest(0).path);
@@ skipping 127 matching lines @@
       "Sec-WebSocket-Key: key\r\n"
       "\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
 }
 
 TEST_F(HttpServerTest, RequestWithTooLargeBody) {
   class TestURLFetcherDelegate : public URLFetcherDelegate {
    public:
     TestURLFetcherDelegate(const base::Closure& quit_loop_func)
         : quit_loop_func_(quit_loop_func) {}
-    virtual ~TestURLFetcherDelegate() {}
+    ~TestURLFetcherDelegate() override {}
 
-    virtual void OnURLFetchComplete(const URLFetcher* source) override {
+    void OnURLFetchComplete(const URLFetcher* source) override {
       EXPECT_EQ(HTTP_INTERNAL_SERVER_ERROR, source->GetResponseCode());
       quit_loop_func_.Run();
     }
 
    private:
     base::Closure quit_loop_func_;
   };
 
   base::RunLoop run_loop;
   TestURLFetcherDelegate delegate(run_loop.QuitClosure());
@@ skipping 43 matching lines @@
 }
 
 class MockStreamSocket : public StreamSocket {
  public:
   MockStreamSocket()
       : connected_(true),
         read_buf_(NULL),
         read_buf_len_(0) {}
 
   // StreamSocket
-  virtual int Connect(const CompletionCallback& callback) override {
+  int Connect(const CompletionCallback& callback) override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual void Disconnect() override {
+  void Disconnect() override {
     connected_ = false;
     if (!read_callback_.is_null()) {
       read_buf_ = NULL;
       read_buf_len_ = 0;
       base::ResetAndReturn(&read_callback_).Run(ERR_CONNECTION_CLOSED);
     }
   }
-  virtual bool IsConnected() const override { return connected_; }
-  virtual bool IsConnectedAndIdle() const override { return IsConnected(); }
-  virtual int GetPeerAddress(IPEndPoint* address) const override {
+  bool IsConnected() const override { return connected_; }
+  bool IsConnectedAndIdle() const override { return IsConnected(); }
+  int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const override {
+  int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual const BoundNetLog& NetLog() const override { return net_log_; }
-  virtual void SetSubresourceSpeculation() override {}
-  virtual void SetOmniboxSpeculation() override {}
-  virtual bool WasEverUsed() const override { return true; }
-  virtual bool UsingTCPFastOpen() const override { return false; }
-  virtual bool WasNpnNegotiated() const override { return false; }
-  virtual NextProto GetNegotiatedProtocol() const override {
-    return kProtoUnknown;
-  }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
+  const BoundNetLog& NetLog() const override { return net_log_; }
+  void SetSubresourceSpeculation() override {}
+  void SetOmniboxSpeculation() override {}
+  bool WasEverUsed() const override { return true; }
+  bool UsingTCPFastOpen() const override { return false; }
+  bool WasNpnNegotiated() const override { return false; }
+  NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
+  bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket
-  virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) override {
+  int Read(IOBuffer* buf,
+           int buf_len,
+           const CompletionCallback& callback) override {
     if (!connected_) {
       return ERR_SOCKET_NOT_CONNECTED;
     }
     if (pending_read_data_.empty()) {
       read_buf_ = buf;
       read_buf_len_ = buf_len;
       read_callback_ = callback;
       return ERR_IO_PENDING;
     }
     DCHECK_GT(buf_len, 0);
     int read_len = std::min(static_cast<int>(pending_read_data_.size()),
                             buf_len);
     memcpy(buf->data(), pending_read_data_.data(), read_len);
     pending_read_data_.erase(0, read_len);
     return read_len;
   }
-  virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) override {
+  int Write(IOBuffer* buf,
+            int buf_len,
+            const CompletionCallback& callback) override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual int SetReceiveBufferSize(int32 size) override {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual int SetSendBufferSize(int32 size) override {
-    return ERR_NOT_IMPLEMENTED;
-  }
+  int SetReceiveBufferSize(int32 size) override { return ERR_NOT_IMPLEMENTED; }
+  int SetSendBufferSize(int32 size) override { return ERR_NOT_IMPLEMENTED; }
 
   void DidRead(const char* data, int data_len) {
     if (!read_buf_.get()) {
       pending_read_data_.append(data, data_len);
       return;
     }
     int read_len = std::min(data_len, read_buf_len_);
     memcpy(read_buf_->data(), data, read_len);
     pending_read_data_.assign(data + read_len, data_len - read_len);
     read_buf_ = NULL;
     read_buf_len_ = 0;
     base::ResetAndReturn(&read_callback_).Run(read_len);
   }
 
  private:
-  virtual ~MockStreamSocket() {}
+  ~MockStreamSocket() override {}
 
   bool connected_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   CompletionCallback read_callback_;
   std::string pending_read_data_;
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(MockStreamSocket);
 };
@@ skipping 53 matching lines @@
   ASSERT_EQ(client_connection_id, GetConnectionId(2));
   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
   std::string response3;
   ASSERT_TRUE(client.ReadResponse(&response3));
   ASSERT_TRUE(StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
   ASSERT_TRUE(EndsWith(response3, "Content for /test3", true));
 }
 
 class CloseOnConnectHttpServerTest : public HttpServerTest {
  public:
-  virtual void OnConnect(int connection_id) override {
+  void OnConnect(int connection_id) override {
     connection_ids_.push_back(connection_id);
     server_->Close(connection_id);
   }
 
  protected:
   std::vector<int> connection_ids_;
 };
 
 TEST_F(CloseOnConnectHttpServerTest, ServerImmediatelyClosesConnection) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET / HTTP/1.1\r\n\r\n");
   ASSERT_FALSE(RunUntilRequestsReceived(1));
   ASSERT_EQ(1ul, connection_ids_.size());
   ASSERT_EQ(0ul, requests_.size());
 }
 
 }  // namespace
 
 }  // namespace net