Standardize usage of virtual/override/final in net/

net/http/http_network_transaction_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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 8173 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response);
 
   base::DeleteFile(temp_file, false);
 }
 
 TEST_P(HttpNetworkTransactionTest, CancelDuringInitRequestBody) {
   class FakeUploadElementReader : public UploadElementReader {
    public:
     FakeUploadElementReader() {}
-    virtual ~FakeUploadElementReader() {}
+    ~FakeUploadElementReader() override {}
 
     const CompletionCallback& callback() const { return callback_; }
 
     // UploadElementReader overrides:
-    virtual int Init(const CompletionCallback& callback) override {
+    int Init(const CompletionCallback& callback) override {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
-    virtual uint64 GetContentLength() const override { return 0; }
-    virtual uint64 BytesRemaining() const override { return 0; }
-    virtual int Read(IOBuffer* buf,
-                     int buf_length,
-                     const CompletionCallback& callback) override {
+    uint64 GetContentLength() const override { return 0; }
+    uint64 BytesRemaining() const override { return 0; }
+    int Read(IOBuffer* buf,
+             int buf_length,
+             const CompletionCallback& callback) override {
       return ERR_FAILED;
     }
 
    private:
     CompletionCallback callback_;
   };
 
   FakeUploadElementReader* fake_reader = new FakeUploadElementReader;
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(fake_reader);
@@ skipping 872 matching lines @@
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_FALSE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 }
 
 class CapturingProxyResolver : public ProxyResolver {
  public:
   CapturingProxyResolver() : ProxyResolver(false /* expects_pac_bytes */) {}
-  virtual ~CapturingProxyResolver() {}
+  ~CapturingProxyResolver() override {}
 
-  virtual int GetProxyForURL(const GURL& url,
-                             ProxyInfo* results,
-                             const CompletionCallback& callback,
-                             RequestHandle* request,
-                             const BoundNetLog& net_log) override {
+  int GetProxyForURL(const GURL& url,
+                     ProxyInfo* results,
+                     const CompletionCallback& callback,
+                     RequestHandle* request,
+                     const BoundNetLog& net_log) override {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
     results->UseProxyServer(proxy_server);
     resolved_.push_back(url);
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) override {
-    NOTREACHED();
-  }
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
-  virtual LoadState GetLoadState(RequestHandle request) const override {
+  LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() override {
-    NOTREACHED();
-  }
+  void CancelSetPacScript() override { NOTREACHED(); }
 
-  virtual int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
-                           const CompletionCallback& /*callback*/) override {
+  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
+                   const CompletionCallback& /*callback*/) override {
     return OK;
   }
 
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
   std::vector<GURL> resolved_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingProxyResolver);
 };
@@ skipping 914 matching lines @@
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 }
 
 // A subclass of HttpAuthHandlerMock that records the request URL when
 // it gets it. This is needed since the auth handler may get destroyed
 // before we get a chance to query it.
 class UrlRecordingHttpAuthHandlerMock : public HttpAuthHandlerMock {
  public:
   explicit UrlRecordingHttpAuthHandlerMock(GURL* url) : url_(url) {}
 
-  virtual ~UrlRecordingHttpAuthHandlerMock() {}
+  ~UrlRecordingHttpAuthHandlerMock() override {}
 
  protected:
-  virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
-                                    const HttpRequestInfo* request,
-                                    const CompletionCallback& callback,
-                                    std::string* auth_token) override {
+  int GenerateAuthTokenImpl(const AuthCredentials* credentials,
+                            const HttpRequestInfo* request,
+                            const CompletionCallback& callback,
+                            std::string* auth_token) override {
     *url_ = request->url;
     return HttpAuthHandlerMock::GenerateAuthTokenImpl(
         credentials, request, callback, auth_token);
   }
 
  private:
   GURL* url_;
 };
 
 TEST_P(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
@@ skipping 1066 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
 class OneTimeCachingHostResolver : public net::HostResolver {
  public:
   explicit OneTimeCachingHostResolver(const HostPortPair& host_port)
       : host_port_(host_port) {}
-  virtual ~OneTimeCachingHostResolver() {}
+  ~OneTimeCachingHostResolver() override {}
 
   RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); }
 
   // HostResolver methods:
-  virtual int Resolve(const RequestInfo& info,
-                      RequestPriority priority,
-                      AddressList* addresses,
-                      const CompletionCallback& callback,
-                      RequestHandle* out_req,
-                      const BoundNetLog& net_log) override {
+  int Resolve(const RequestInfo& info,
+              RequestPriority priority,
+              AddressList* addresses,
+              const CompletionCallback& callback,
+              RequestHandle* out_req,
+              const BoundNetLog& net_log) override {
     return host_resolver_.Resolve(
         info, priority, addresses, callback, out_req, net_log);
   }
 
-  virtual int ResolveFromCache(const RequestInfo& info,
-                               AddressList* addresses,
-                               const BoundNetLog& net_log) override {
+  int ResolveFromCache(const RequestInfo& info,
+                       AddressList* addresses,
+                       const BoundNetLog& net_log) override {
     int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
       host_resolver_.GetHostCache()->clear();
     return rv;
   }
 
-  virtual void CancelRequest(RequestHandle req) override {
+  void CancelRequest(RequestHandle req) override {
     host_resolver_.CancelRequest(req);
   }
 
   MockCachingHostResolver* GetMockHostResolver() {
     return &host_resolver_;
   }
 
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
@@ skipping 1004 matching lines @@
   EXPECT_EQ("bar", foo);
 }
 
 namespace {
 
 // Fake HttpStreamBase that simply records calls to SetPriority().
 class FakeStream : public HttpStreamBase,
                    public base::SupportsWeakPtr<FakeStream> {
  public:
   explicit FakeStream(RequestPriority priority) : priority_(priority) {}
-  virtual ~FakeStream() {}
+  ~FakeStream() override {}
 
   RequestPriority priority() const { return priority_; }
 
-  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 {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
+  int ReadResponseHeaders(const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
-                               const CompletionCallback& callback) override {
+  int ReadResponseBody(IOBuffer* buf,
+                       int buf_len,
+                       const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual void Close(bool not_reusable) override {}
+  void Close(bool not_reusable) override {}
 
-  virtual bool IsResponseBodyComplete() const override {
+  bool IsResponseBodyComplete() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool CanFindEndOfResponse() const override {
-    return false;
-  }
+  bool CanFindEndOfResponse() const override { return false; }
 
-  virtual bool IsConnectionReused() const override {
+  bool IsConnectionReused() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void SetConnectionReused() override {
-    ADD_FAILURE();
-  }
+  void SetConnectionReused() override { ADD_FAILURE(); }
 
-  virtual bool IsConnectionReusable() const override {
+  bool IsConnectionReusable() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual int64 GetTotalReceivedBytes() const override {
+  int64 GetTotalReceivedBytes() const override {
     ADD_FAILURE();
     return 0;
   }
 
-  virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const override {
+  bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) override {
+  void GetSSLInfo(SSLInfo* ssl_info) override { ADD_FAILURE(); }
+
+  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {
     ADD_FAILURE();
   }
 
-  virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) override {
-    ADD_FAILURE();
-  }
-
-  virtual bool IsSpdyHttpStream() const override {
+  bool IsSpdyHttpStream() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void Drain(HttpNetworkSession* session) override {
-    ADD_FAILURE();
-  }
+  void Drain(HttpNetworkSession* session) override { ADD_FAILURE(); }
 
-  virtual void SetPriority(RequestPriority priority) override {
-    priority_ = priority;
-  }
+  void SetPriority(RequestPriority priority) override { priority_ = priority; }
 
  private:
   RequestPriority priority_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStream);
 };
 
 // Fake HttpStreamRequest that simply records calls to SetPriority()
 // and vends FakeStreams with its current priority.
 class FakeStreamRequest : public HttpStreamRequest,
                           public base::SupportsWeakPtr<FakeStreamRequest> {
  public:
   FakeStreamRequest(RequestPriority priority,
                     HttpStreamRequest::Delegate* delegate)
       : priority_(priority),
         delegate_(delegate),
         websocket_stream_create_helper_(NULL) {}
 
   FakeStreamRequest(RequestPriority priority,
                     HttpStreamRequest::Delegate* delegate,
                     WebSocketHandshakeStreamBase::CreateHelper* create_helper)
       : priority_(priority),
         delegate_(delegate),
         websocket_stream_create_helper_(create_helper) {}
 
-  virtual ~FakeStreamRequest() {}
+  ~FakeStreamRequest() override {}
 
   RequestPriority priority() const { return priority_; }
 
   const WebSocketHandshakeStreamBase::CreateHelper*
   websocket_stream_create_helper() const {
     return websocket_stream_create_helper_;
   }
 
   // Create a new FakeStream and pass it to the request's
   // delegate. Returns a weak pointer to the FakeStream.
   base::WeakPtr<FakeStream> FinishStreamRequest() {
     FakeStream* fake_stream = new FakeStream(priority_);
     // Do this before calling OnStreamReady() as OnStreamReady() may
     // immediately delete |fake_stream|.
     base::WeakPtr<FakeStream> weak_stream = fake_stream->AsWeakPtr();
     delegate_->OnStreamReady(SSLConfig(), ProxyInfo(), fake_stream);
     return weak_stream;
   }
 
-  virtual int RestartTunnelWithProxyAuth(
-      const AuthCredentials& credentials) override {
+  int RestartTunnelWithProxyAuth(const AuthCredentials& credentials) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual LoadState GetLoadState() const override {
+  LoadState GetLoadState() const override {
     ADD_FAILURE();
     return LoadState();
   }
 
-  virtual void SetPriority(RequestPriority priority) override {
-    priority_ = priority;
-  }
+  void SetPriority(RequestPriority priority) override { priority_ = priority; }
 
-  virtual bool was_npn_negotiated() const override {
-    return false;
-  }
+  bool was_npn_negotiated() const override { return false; }
 
-  virtual NextProto protocol_negotiated() const override {
-    return kProtoUnknown;
-  }
+  NextProto protocol_negotiated() const override { return kProtoUnknown; }
 
-  virtual bool using_spdy() const override {
-    return false;
-  }
+  bool using_spdy() const override { return false; }
 
  private:
   RequestPriority priority_;
   HttpStreamRequest::Delegate* const delegate_;
   WebSocketHandshakeStreamBase::CreateHelper* websocket_stream_create_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamRequest);
 };
 
 // Fake HttpStreamFactory that vends FakeStreamRequests.
 class FakeStreamFactory : public HttpStreamFactory {
  public:
   FakeStreamFactory() {}
-  virtual ~FakeStreamFactory() {}
+  ~FakeStreamFactory() override {}
 
   // Returns a WeakPtr<> to the last HttpStreamRequest returned by
   // RequestStream() (which may be NULL if it was destroyed already).
   base::WeakPtr<FakeStreamRequest> last_stream_request() {
     return last_stream_request_;
   }
 
-  virtual HttpStreamRequest* RequestStream(
-      const HttpRequestInfo& info,
-      RequestPriority priority,
-      const SSLConfig& server_ssl_config,
-      const SSLConfig& proxy_ssl_config,
-      HttpStreamRequest::Delegate* delegate,
-      const BoundNetLog& net_log) override {
+  HttpStreamRequest* RequestStream(const HttpRequestInfo& info,
+                                   RequestPriority priority,
+                                   const SSLConfig& server_ssl_config,
+                                   const SSLConfig& proxy_ssl_config,
+                                   HttpStreamRequest::Delegate* delegate,
+                                   const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
     last_stream_request_ = fake_request->AsWeakPtr();
     return fake_request;
   }
 
-  virtual HttpStreamRequest* RequestWebSocketHandshakeStream(
+  HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
       const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request =
         new FakeStreamRequest(priority, delegate, create_helper);
     last_stream_request_ = fake_request->AsWeakPtr();
     return fake_request;
   }
 
-  virtual void PreconnectStreams(int num_streams,
-                                 const HttpRequestInfo& info,
-                                 RequestPriority priority,
-                                 const SSLConfig& server_ssl_config,
-                                 const SSLConfig& proxy_ssl_config) override {
+  void PreconnectStreams(int num_streams,
+                         const HttpRequestInfo& info,
+                         RequestPriority priority,
+                         const SSLConfig& server_ssl_config,
+                         const SSLConfig& proxy_ssl_config) override {
     ADD_FAILURE();
   }
 
-  virtual const HostMappingRules* GetHostMappingRules() const override {
+  const HostMappingRules* GetHostMappingRules() const override {
     ADD_FAILURE();
     return NULL;
   }
 
  private:
   base::WeakPtr<FakeStreamRequest> last_stream_request_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStreamFactory);
 };
 
 // TODO(yhirano): Split this class out into a net/websockets file, if it is
 // worth doing.
 class FakeWebSocketStreamCreateHelper :
       public WebSocketHandshakeStreamBase::CreateHelper {
  public:
-  virtual WebSocketHandshakeStreamBase* CreateBasicStream(
+  WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
       bool using_proxy) override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
+  WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
       bool use_relative_url) override {
     NOTREACHED();
     return NULL;
   };
 
-  virtual ~FakeWebSocketStreamCreateHelper() {}
+  ~FakeWebSocketStreamCreateHelper() override {}
 
   virtual scoped_ptr<WebSocketStream> Upgrade() {
     NOTREACHED();
     return scoped_ptr<WebSocketStream>();
   }
 };
 
 }  // namespace
 
 // Make sure that HttpNetworkTransaction passes on its priority to its
@@ skipping 744 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 }  // namespace net