Standardize usage of virtual/override/final in net/

net/http/http_stream_factory_impl_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/http/http_stream_factory_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 34 matching lines @@
 
 class MockWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
  public:
   enum StreamType {
     kStreamTypeBasic,
     kStreamTypeSpdy,
   };
 
   explicit MockWebSocketHandshakeStream(StreamType type) : type_(type) {}
 
-  virtual ~MockWebSocketHandshakeStream() {}
+  ~MockWebSocketHandshakeStream() override {}
 
   StreamType type() const {
     return type_;
   }
 
   // HttpStreamBase methods
-  virtual int InitializeStream(const HttpRequestInfo* request_info,
-                               RequestPriority priority,
-                               const BoundNetLog& net_log,
-                               const CompletionCallback& callback) override {
+  int InitializeStream(const HttpRequestInfo* request_info,
+                       RequestPriority priority,
+                       const BoundNetLog& net_log,
+                       const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual int SendRequest(const HttpRequestHeaders& request_headers,
-                          HttpResponseInfo* response,
-                          const CompletionCallback& callback) override {
+  int SendRequest(const HttpRequestHeaders& request_headers,
+                  HttpResponseInfo* response,
+                  const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
+  int ReadResponseHeaders(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual int ReadResponseBody(IOBuffer* buf,
-                               int buf_len,
-                               const CompletionCallback& callback) override {
+  int ReadResponseBody(IOBuffer* buf,
+                       int buf_len,
+                       const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual void Close(bool not_reusable) override {}
-  virtual bool IsResponseBodyComplete() const override { return false; }
-  virtual bool CanFindEndOfResponse() const override { return false; }
-  virtual bool IsConnectionReused() const override { return false; }
-  virtual void SetConnectionReused() override {}
-  virtual bool IsConnectionReusable() const override { return false; }
-  virtual int64 GetTotalReceivedBytes() const override { return 0; }
-  virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      override {
+  void Close(bool not_reusable) override {}
+  bool IsResponseBodyComplete() const override { return false; }
+  bool CanFindEndOfResponse() const override { return false; }
+  bool IsConnectionReused() const override { return false; }
+  void SetConnectionReused() override {}
+  bool IsConnectionReusable() const override { return false; }
+  int64 GetTotalReceivedBytes() const override { return 0; }
+  bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
     return false;
   }
-  virtual void GetSSLInfo(SSLInfo* ssl_info) override {}
-  virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) override {}
-  virtual bool IsSpdyHttpStream() const override { return false; }
-  virtual void Drain(HttpNetworkSession* session) override {}
-  virtual void SetPriority(RequestPriority priority) override {}
+  void GetSSLInfo(SSLInfo* ssl_info) override {}
+  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
+  bool IsSpdyHttpStream() const override { return false; }
+  void Drain(HttpNetworkSession* session) override {}
+  void SetPriority(RequestPriority priority) override {}
 
-  virtual scoped_ptr<WebSocketStream> Upgrade() override {
+  scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
  private:
   const StreamType type_;
 };
 
 // HttpStreamFactoryImpl subclass that can wait until a preconnect is complete.
 class MockHttpStreamFactoryImplForPreconnect : public HttpStreamFactoryImpl {
  public:
   MockHttpStreamFactoryImplForPreconnect(HttpNetworkSession* session,
                                          bool for_websockets)
       : HttpStreamFactoryImpl(session, for_websockets),
         preconnect_done_(false),
         waiting_for_preconnect_(false) {}
 
 
   void WaitForPreconnects() {
     while (!preconnect_done_) {
       waiting_for_preconnect_ = true;
       base::MessageLoop::current()->Run();
       waiting_for_preconnect_ = false;
     }
   }
 
  private:
   // HttpStreamFactoryImpl methods.
-  virtual void OnPreconnectsCompleteInternal() override {
+  void OnPreconnectsCompleteInternal() override {
     preconnect_done_ = true;
     if (waiting_for_preconnect_)
       base::MessageLoop::current()->Quit();
   }
 
   bool preconnect_done_;
   bool waiting_for_preconnect_;
 };
 
 class StreamRequestWaiter : public HttpStreamRequest::Delegate {
  public:
   StreamRequestWaiter()
       : waiting_for_stream_(false),
         stream_done_(false) {}
 
   // HttpStreamRequest::Delegate
 
-  virtual void OnStreamReady(
-      const SSLConfig& used_ssl_config,
-      const ProxyInfo& used_proxy_info,
-      HttpStreamBase* stream) override {
+  void OnStreamReady(const SSLConfig& used_ssl_config,
+                     const ProxyInfo& used_proxy_info,
+                     HttpStreamBase* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->Quit();
     stream_.reset(stream);
     used_ssl_config_ = used_ssl_config;
     used_proxy_info_ = used_proxy_info;
   }
 
-  virtual void OnWebSocketHandshakeStreamReady(
+  void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
       WebSocketHandshakeStreamBase* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->Quit();
     websocket_stream_.reset(stream);
     used_ssl_config_ = used_ssl_config;
     used_proxy_info_ = used_proxy_info;
   }
 
-  virtual void OnStreamFailed(
-      int status,
-      const SSLConfig& used_ssl_config) override {}
+  void OnStreamFailed(int status, const SSLConfig& used_ssl_config) override {}
 
-  virtual void OnCertificateError(
-      int status,
-      const SSLConfig& used_ssl_config,
-      const SSLInfo& ssl_info) override {}
+  void OnCertificateError(int status,
+                          const SSLConfig& used_ssl_config,
+                          const SSLInfo& ssl_info) override {}
 
-  virtual void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
-                                const SSLConfig& used_ssl_config,
-                                const ProxyInfo& used_proxy_info,
-                                HttpAuthController* auth_controller) override {}
+  void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
+                        const SSLConfig& used_ssl_config,
+                        const ProxyInfo& used_proxy_info,
+                        HttpAuthController* auth_controller) override {}
 
-  virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
-                                 SSLCertRequestInfo* cert_info) override {}
+  void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
+                         SSLCertRequestInfo* cert_info) override {}
 
-  virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
-                                          const SSLConfig& used_ssl_config,
-                                          const ProxyInfo& used_proxy_info,
-                                          HttpStreamBase* stream) override {}
+  void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
+                                  const SSLConfig& used_ssl_config,
+                                  const ProxyInfo& used_proxy_info,
+                                  HttpStreamBase* stream) override {}
 
   void WaitForStream() {
     while (!stream_done_) {
       waiting_for_stream_ = true;
       base::MessageLoop::current()->Run();
       waiting_for_stream_ = false;
     }
   }
 
   const SSLConfig& used_ssl_config() const {
@@ skipping 25 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
 };
 
 class WebSocketSpdyHandshakeStream : public MockWebSocketHandshakeStream {
  public:
   explicit WebSocketSpdyHandshakeStream(
       const base::WeakPtr<SpdySession>& spdy_session)
       : MockWebSocketHandshakeStream(kStreamTypeSpdy),
         spdy_session_(spdy_session) {}
 
-  virtual ~WebSocketSpdyHandshakeStream() {}
+  ~WebSocketSpdyHandshakeStream() override {}
 
   SpdySession* spdy_session() { return spdy_session_.get(); }
 
  private:
   base::WeakPtr<SpdySession> spdy_session_;
 };
 
 class WebSocketBasicHandshakeStream : public MockWebSocketHandshakeStream {
  public:
   explicit WebSocketBasicHandshakeStream(
       scoped_ptr<ClientSocketHandle> connection)
       : MockWebSocketHandshakeStream(kStreamTypeBasic),
         connection_(connection.Pass()) {}
 
-  virtual ~WebSocketBasicHandshakeStream() {
+  ~WebSocketBasicHandshakeStream() override {
     connection_->socket()->Disconnect();
   }
 
   ClientSocketHandle* connection() { return connection_.get(); }
 
  private:
   scoped_ptr<ClientSocketHandle> connection_;
 };
 
 class WebSocketStreamCreateHelper
     : public WebSocketHandshakeStreamBase::CreateHelper {
  public:
-  virtual ~WebSocketStreamCreateHelper() {}
+  ~WebSocketStreamCreateHelper() override {}
 
-  virtual WebSocketHandshakeStreamBase* CreateBasicStream(
+  WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
       bool using_proxy) override {
     return new WebSocketBasicHandshakeStream(connection.Pass());
   }
 
-  virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
+  WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& spdy_session,
       bool use_relative_url) override {
     return new WebSocketSpdyHandshakeStream(spdy_session);
   }
 };
 
 struct TestCase {
   int num_streams;
   bool ssl;
 };
@@ skipping 1021 matching lines @@
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net