Standardize usage of virtual/override/final in net/

net/websockets/websocket_job_test.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 "net/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 namespace net {
 
 namespace {
 
 class MockSocketStream : public SocketStream {
  public:
   MockSocketStream(const GURL& url, SocketStream::Delegate* delegate,
                    URLRequestContext* context, CookieStore* cookie_store)
       : SocketStream(url, delegate, context, cookie_store) {}
 
-  virtual void Connect() override {}
-  virtual bool SendData(const char* data, int len) override {
+  void Connect() override {}
+  bool SendData(const char* data, int len) override {
     sent_data_ += std::string(data, len);
     return true;
   }
 
-  virtual void Close() override {}
-  virtual void RestartWithAuth(
-      const AuthCredentials& credentials) override {
-  }
+  void Close() override {}
+  void RestartWithAuth(const AuthCredentials& credentials) override {}
 
-  virtual void DetachDelegate() override {
-    delegate_ = NULL;
-  }
+  void DetachDelegate() override { delegate_ = NULL; }
 
   const std::string& sent_data() const {
     return sent_data_;
   }
 
  protected:
-  virtual ~MockSocketStream() {}
+  ~MockSocketStream() override {}
 
  private:
   std::string sent_data_;
 };
 
 class MockSocketStreamDelegate : public SocketStream::Delegate {
  public:
   MockSocketStreamDelegate()
       : amount_sent_(0), allow_all_cookies_(true) {}
   void set_allow_all_cookies(bool allow_all_cookies) {
     allow_all_cookies_ = allow_all_cookies;
   }
-  virtual ~MockSocketStreamDelegate() {}
+  ~MockSocketStreamDelegate() override {}
 
   void SetOnStartOpenConnection(const base::Closure& callback) {
     on_start_open_connection_ = callback;
   }
   void SetOnConnected(const base::Closure& callback) {
     on_connected_ = callback;
   }
   void SetOnSentData(const base::Closure& callback) {
     on_sent_data_ = callback;
   }
   void SetOnReceivedData(const base::Closure& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const base::Closure& callback) {
     on_close_ = callback;
   }
 
-  virtual int OnStartOpenConnection(
-      SocketStream* socket,
-      const CompletionCallback& callback) override {
+  int OnStartOpenConnection(SocketStream* socket,
+                            const CompletionCallback& callback) override {
     if (!on_start_open_connection_.is_null())
       on_start_open_connection_.Run();
     return OK;
   }
-  virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) override {
+  void OnConnected(SocketStream* socket,
+                   int max_pending_send_allowed) override {
     if (!on_connected_.is_null())
       on_connected_.Run();
   }
-  virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) override {
+  void OnSentData(SocketStream* socket, int amount_sent) override {
     amount_sent_ += amount_sent;
     if (!on_sent_data_.is_null())
       on_sent_data_.Run();
   }
-  virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) override {
+  void OnReceivedData(SocketStream* socket,
+                      const char* data,
+                      int len) override {
     received_data_ += std::string(data, len);
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(SocketStream* socket) override {
+  void OnClose(SocketStream* socket) override {
     if (!on_close_.is_null())
       on_close_.Run();
   }
-  virtual bool CanGetCookies(SocketStream* socket,
-                             const GURL& url) override {
+  bool CanGetCookies(SocketStream* socket, const GURL& url) override {
     return allow_all_cookies_;
   }
-  virtual bool CanSetCookie(SocketStream* request,
-                            const GURL& url,
-                            const std::string& cookie_line,
-                            CookieOptions* options) override {
+  bool CanSetCookie(SocketStream* request,
+                    const GURL& url,
+                    const std::string& cookie_line,
+                    CookieOptions* options) override {
     return allow_all_cookies_;
   }
 
   size_t amount_sent() const { return amount_sent_; }
   const std::string& received_data() const { return received_data_; }
 
  private:
   int amount_sent_;
   bool allow_all_cookies_;
   std::string received_data_;
@@ skipping 34 matching lines @@
         if (!result.empty()) {
           result += "; ";
         }
         result += entry.cookie_line;
       }
     }
     return result;
   }
 
   // CookieStore:
-  virtual void SetCookieWithOptionsAsync(
-      const GURL& url,
-      const std::string& cookie_line,
-      const CookieOptions& options,
-      const SetCookiesCallback& callback) override {
+  void SetCookieWithOptionsAsync(const GURL& url,
+                                 const std::string& cookie_line,
+                                 const CookieOptions& options,
+                                 const SetCookiesCallback& callback) override {
     bool result = SetCookieWithOptions(url, cookie_line, options);
     if (!callback.is_null())
       callback.Run(result);
   }
 
-  virtual void GetCookiesWithOptionsAsync(
-      const GURL& url,
-      const CookieOptions& options,
-      const GetCookiesCallback& callback) override {
+  void GetCookiesWithOptionsAsync(const GURL& url,
+                                  const CookieOptions& options,
+                                  const GetCookiesCallback& callback) override {
     if (!callback.is_null())
       callback.Run(GetCookiesWithOptions(url, options));
   }
 
-  virtual void GetAllCookiesForURLAsync(
+  void GetAllCookiesForURLAsync(
       const GURL& url,
       const GetCookieListCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteCookieAsync(const GURL& url,
-                                 const std::string& cookie_name,
-                                 const base::Closure& callback) override {
+  void DeleteCookieAsync(const GURL& url,
+                         const std::string& cookie_name,
+                         const base::Closure& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteAllCreatedBetweenAsync(
-      const base::Time& delete_begin,
-      const base::Time& delete_end,
-      const DeleteCallback& callback) override {
+  void DeleteAllCreatedBetweenAsync(const base::Time& delete_begin,
+                                    const base::Time& delete_end,
+                                    const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteAllCreatedBetweenForHostAsync(
+  void DeleteAllCreatedBetweenForHostAsync(
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
       const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override {
+  void DeleteSessionCookiesAsync(const DeleteCallback&) override {
     ADD_FAILURE();
   }
 
-  virtual CookieMonster* GetCookieMonster() override { return NULL; }
+  CookieMonster* GetCookieMonster() override { return NULL; }
 
   const std::vector<Entry>& entries() const { return entries_; }
 
  private:
   friend class base::RefCountedThreadSafe<MockCookieStore>;
-  virtual ~MockCookieStore() {}
+  ~MockCookieStore() override {}
 
   std::vector<Entry> entries_;
 };
 
 class MockSSLConfigService : public SSLConfigService {
  public:
-  virtual void GetSSLConfig(SSLConfig* config) override {}
+  void GetSSLConfig(SSLConfig* config) override {}
 
  protected:
-  virtual ~MockSSLConfigService() {}
+  ~MockSSLConfigService() override {}
 };
 
 class MockURLRequestContext : public URLRequestContext {
  public:
   explicit MockURLRequestContext(CookieStore* cookie_store)
       : transport_security_state_() {
     set_cookie_store(cookie_store);
     set_transport_security_state(&transport_security_state_);
     base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
     bool include_subdomains = false;
     transport_security_state_.AddHSTS("upgrademe.com", expiry,
                                       include_subdomains);
   }
 
-  virtual ~MockURLRequestContext() {
-    AssertNoURLRequests();
-  }
+  ~MockURLRequestContext() override { AssertNoURLRequests(); }
 
  private:
   TransportSecurityState transport_security_state_;
 };
 
 class MockHttpTransactionFactory : public HttpTransactionFactory {
  public:
   MockHttpTransactionFactory(NextProto next_proto,
                              OrderedSocketData* data,
                              bool enable_websocket_over_spdy) {
     data_ = data;
     MockConnect connect_data(SYNCHRONOUS, OK);
     data_->set_connect_data(connect_data);
     session_deps_.reset(new SpdySessionDependencies(next_proto));
     session_deps_->enable_websocket_over_spdy = enable_websocket_over_spdy;
     session_deps_->socket_factory->AddSocketDataProvider(data_);
     http_session_ =
         SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     spdy_session_key_ = SpdySessionKey(host_port_pair_,
                                             ProxyServer::Direct(),
                                             PRIVACY_MODE_DISABLED);
     session_ = CreateInsecureSpdySession(
         http_session_, spdy_session_key_, BoundNetLog());
   }
 
-  virtual int CreateTransaction(
-      RequestPriority priority,
-      scoped_ptr<HttpTransaction>* trans) override {
+  int CreateTransaction(RequestPriority priority,
+                        scoped_ptr<HttpTransaction>* trans) override {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  virtual HttpCache* GetCache() override {
+  HttpCache* GetCache() override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual HttpNetworkSession* GetSession() override {
-    return http_session_.get();
-  }
+  HttpNetworkSession* GetSession() override { return http_session_.get(); }
 
  private:
   OrderedSocketData* data_;
   scoped_ptr<SpdySessionDependencies> session_deps_;
   scoped_refptr<HttpNetworkSession> http_session_;
   base::WeakPtr<SpdySession> session_;
   HostPortPair host_port_pair_;
   SpdySessionKey spdy_session_key_;
 };
 
@@ skipping 18 matching lines @@
       job_->DetachContext();
       job_->DetachDelegate();
       job_ = NULL;
     }
   }
 
   // SocketStream::Delegate implementation
 
   // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost
 
-  virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) override {
+  void OnConnected(SocketStream* socket,
+                   int max_pending_send_allowed) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
+  void OnSentData(SocketStream* socket, int amount_sent) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnReceivedData(SocketStream* socket,
-                              const char* data,
-                              int len) override {
+  void OnReceivedData(SocketStream* socket,
+                      const char* data,
+                      int len) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnClose(SocketStream* socket) override { DeleteJobMaybe(); }
+  void OnClose(SocketStream* socket) override { DeleteJobMaybe(); }
 
-  virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) override {
+  void OnAuthRequired(SocketStream* socket,
+                      AuthChallengeInfo* auth_info) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnSSLCertificateError(SocketStream* socket,
-                                     const SSLInfo& ssl_info,
-                                     bool fatal) override {
+  void OnSSLCertificateError(SocketStream* socket,
+                             const SSLInfo& ssl_info,
+                             bool fatal) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnError(const SocketStream* socket, int error) override {
+  void OnError(const SocketStream* socket, int error) override {
     DeleteJobMaybe();
   }
 
   // CanGetCookies() and CanSetCookies() do not appear to be able to delete the
   // WebSocketJob object.
 
  private:
   scoped_refptr<WebSocketJob> job_;
   bool delete_next_;
 };
@@ skipping 894 matching lines @@
   job()->Connect();
   SetDeleteNext();
   job()->OnReceivedData(
       socket_.get(), kMinimalResponse, arraysize(kMinimalResponse) - 1);
   EXPECT_FALSE(job());
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 }  // namespace net