Add OVERRIDE to net/.

BUG=104314

Review URL: http://codereview.chromium.org/8568021

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@110231 0039d316-1c4b-4281-b951-d872f2087c98

23 files changed, 194 insertions, 174 deletions

diff --git a/net/http/disk_cache_based_ssl_host_info.h b/net/http/disk_cache_based_ssl_host_info.h
index 7adce48..a5dc861 100644
--- a/net/http/disk_cache_based_ssl_host_info.h
+++ b/net/http/disk_cache_based_ssl_host_info.h
@@ -33,9 +33,9 @@ class NET_EXPORT_PRIVATE DiskCacheBasedSSLHostInfo
                             HttpCache* http_cache);
 
   // Implementation of SSLHostInfo
-  virtual void Start();
-  virtual int WaitForDataReady(OldCompletionCallback* callback);
-  virtual void Persist();
+  virtual void Start() OVERRIDE;
+  virtual int WaitForDataReady(OldCompletionCallback* callback) OVERRIDE;
+  virtual void Persist() OVERRIDE;
 
  private:
   enum State {
@@ -66,7 +66,7 @@ class NET_EXPORT_PRIVATE DiskCacheBasedSSLHostInfo
     disk_cache::Entry* entry() const { return entry_; }
 
     // CallbackRunner<Tuple1<int> >:
-    virtual void RunWithParams(const Tuple1<int>& params);
+    virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
 
    private:
     base::WeakPtr<DiskCacheBasedSSLHostInfo> obj_;
diff --git a/net/http/http_auth_filter.h b/net/http/http_auth_filter.h
index bf137c9..4909a32 100644
--- a/net/http/http_auth_filter.h
+++ b/net/http/http_auth_filter.h
@@ -47,7 +47,7 @@ class NET_EXPORT HttpAuthFilterWhitelist : public HttpAuthFilter {
   const ProxyBypassRules& rules() const { return rules_; }
 
   // HttpAuthFilter methods:
-  virtual bool IsValid(const GURL& url, HttpAuth::Target target) const;
+  virtual bool IsValid(const GURL& url, HttpAuth::Target target) const OVERRIDE;
 
  private:
   // Installs the whitelist.
diff --git a/net/http/http_auth_gssapi_posix.h b/net/http/http_auth_gssapi_posix.h
index ecf057a..96c7176 100644
--- a/net/http/http_auth_gssapi_posix.h
+++ b/net/http/http_auth_gssapi_posix.h
@@ -105,30 +105,30 @@ class NET_EXPORT_PRIVATE GSSAPISharedLibrary : public GSSAPILibrary {
   virtual ~GSSAPISharedLibrary();
 
   // GSSAPILibrary methods:
-  virtual bool Init();
+  virtual bool Init() OVERRIDE;
   virtual OM_uint32 import_name(
       OM_uint32* minor_status,
       const gss_buffer_t input_name_buffer,
       const gss_OID input_name_type,
-      gss_name_t* output_name);
+      gss_name_t* output_name) OVERRIDE;
   virtual OM_uint32 release_name(
       OM_uint32* minor_status,
-      gss_name_t* input_name);
+      gss_name_t* input_name) OVERRIDE;
   virtual OM_uint32 release_buffer(
       OM_uint32* minor_status,
-      gss_buffer_t buffer);
+      gss_buffer_t buffer) OVERRIDE;
   virtual OM_uint32 display_name(
       OM_uint32* minor_status,
       const gss_name_t input_name,
       gss_buffer_t output_name_buffer,
-      gss_OID* output_name_type);
+      gss_OID* output_name_type) OVERRIDE;
   virtual OM_uint32 display_status(
       OM_uint32* minor_status,
       OM_uint32 status_value,
       int status_type,
       const gss_OID mech_type,
       OM_uint32* message_contex,
-      gss_buffer_t status_string);
+      gss_buffer_t status_string) OVERRIDE;
   virtual OM_uint32 init_sec_context(
       OM_uint32* minor_status,
       const gss_cred_id_t initiator_cred_handle,
@@ -142,18 +142,18 @@ class NET_EXPORT_PRIVATE GSSAPISharedLibrary : public GSSAPILibrary {
       gss_OID* actual_mech_type,
       gss_buffer_t output_token,
       OM_uint32* ret_flags,
-      OM_uint32* time_rec);
+      OM_uint32* time_rec) OVERRIDE;
   virtual OM_uint32 wrap_size_limit(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
       int conf_req_flag,
       gss_qop_t qop_req,
       OM_uint32 req_output_size,
-      OM_uint32* max_input_size);
+      OM_uint32* max_input_size) OVERRIDE;
   virtual OM_uint32 delete_sec_context(
       OM_uint32* minor_status,
       gss_ctx_id_t* context_handle,
-      gss_buffer_t output_token);
+      gss_buffer_t output_token) OVERRIDE;
   virtual OM_uint32 inquire_context(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
@@ -163,7 +163,7 @@ class NET_EXPORT_PRIVATE GSSAPISharedLibrary : public GSSAPILibrary {
       gss_OID* mech_type,
       OM_uint32* ctx_flags,
       int* locally_initiated,
-      int* open);
+      int* open) OVERRIDE;
 
  private:
   typedef typeof(&gss_import_name) gss_import_name_type;
diff --git a/net/http/http_auth_handler_basic.h b/net/http/http_auth_handler_basic.h
index 5952d73..7cb79c5 100644
--- a/net/http/http_auth_handler_basic.h
+++ b/net/http/http_auth_handler_basic.h
@@ -22,25 +22,26 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerBasic : public HttpAuthHandler {
     Factory();
     virtual ~Factory();
 
-    virtual int CreateAuthHandler(HttpAuth::ChallengeTokenizer* challenge,
-                                  HttpAuth::Target target,
-                                  const GURL& origin,
-                                  CreateReason reason,
-                                  int digest_nonce_count,
-                                  const BoundNetLog& net_log,
-                                  scoped_ptr<HttpAuthHandler>* handler);
+    virtual int CreateAuthHandler(
+        HttpAuth::ChallengeTokenizer* challenge,
+        HttpAuth::Target target,
+        const GURL& origin,
+        CreateReason reason,
+        int digest_nonce_count,
+        const BoundNetLog& net_log,
+        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
   };
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuth::ChallengeTokenizer* challenge);
+      HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
  protected:
-  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge);
+  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     OldCompletionCallback* callback,
-                                    std::string* auth_token);
+                                    std::string* auth_token) OVERRIDE;
 
  private:
   virtual ~HttpAuthHandlerBasic() {}
diff --git a/net/http/http_auth_handler_digest.h b/net/http/http_auth_handler_digest.h
index 5fc0a38..03406a2 100644
--- a/net/http/http_auth_handler_digest.h
+++ b/net/http/http_auth_handler_digest.h
@@ -39,7 +39,7 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerDigest : public HttpAuthHandler {
   class DynamicNonceGenerator : public NonceGenerator {
    public:
     DynamicNonceGenerator();
-    virtual std::string GenerateNonce() const;
+    virtual std::string GenerateNonce() const OVERRIDE;
    private:
     DISALLOW_COPY_AND_ASSIGN(DynamicNonceGenerator);
   };
@@ -50,7 +50,7 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerDigest : public HttpAuthHandler {
    public:
     explicit FixedNonceGenerator(const std::string& nonce);
 
-    virtual std::string GenerateNonce() const;
+    virtual std::string GenerateNonce() const OVERRIDE;
 
    private:
     const std::string nonce_;
@@ -65,28 +65,29 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerDigest : public HttpAuthHandler {
     // This factory owns the passed in |nonce_generator|.
     void set_nonce_generator(const NonceGenerator* nonce_generator);
 
-    virtual int CreateAuthHandler(HttpAuth::ChallengeTokenizer* challenge,
-                                  HttpAuth::Target target,
-                                  const GURL& origin,
-                                  CreateReason reason,
-                                  int digest_nonce_count,
-                                  const BoundNetLog& net_log,
-                                  scoped_ptr<HttpAuthHandler>* handler);
+    virtual int CreateAuthHandler(
+        HttpAuth::ChallengeTokenizer* challenge,
+        HttpAuth::Target target,
+        const GURL& origin,
+        CreateReason reason,
+        int digest_nonce_count,
+        const BoundNetLog& net_log,
+        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
 
    private:
     scoped_ptr<const NonceGenerator> nonce_generator_;
   };
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuth::ChallengeTokenizer* challenge);
+      HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
  protected:
-  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge);
+  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     OldCompletionCallback* callback,
-                                    std::string* auth_token);
+                                    std::string* auth_token) OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpAuthHandlerDigestTest, ParseChallenge);
diff --git a/net/http/http_auth_handler_factory.h b/net/http/http_auth_handler_factory.h
index 644be67..58db6f6 100644
--- a/net/http/http_auth_handler_factory.h
+++ b/net/http/http_auth_handler_factory.h
@@ -189,7 +189,7 @@ class NET_EXPORT HttpAuthHandlerRegistryFactory
                                 CreateReason reason,
                                 int digest_nonce_count,
                                 const BoundNetLog& net_log,
-                                scoped_ptr<HttpAuthHandler>* handler);
+                                scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
 
  private:
   typedef std::map<std::string, HttpAuthHandlerFactory*> FactoryMap;
diff --git a/net/http/http_auth_handler_mock.h b/net/http/http_auth_handler_mock.h
index 5c87c21..922a5cd 100644
--- a/net/http/http_auth_handler_mock.h
+++ b/net/http/http_auth_handler_mock.h
@@ -43,13 +43,14 @@ class HttpAuthHandlerMock : public HttpAuthHandler {
     }
 
     // HttpAuthHandlerFactory:
-    virtual int CreateAuthHandler(HttpAuth::ChallengeTokenizer* challenge,
-                                  HttpAuth::Target target,
-                                  const GURL& origin,
-                                  CreateReason reason,
-                                  int nonce_count,
-                                  const BoundNetLog& net_log,
-                                  scoped_ptr<HttpAuthHandler>* handler);
+    virtual int CreateAuthHandler(
+        HttpAuth::ChallengeTokenizer* challenge,
+        HttpAuth::Target target,
+        const GURL& origin,
+        CreateReason reason,
+        int nonce_count,
+        const BoundNetLog& net_log,
+        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
 
    private:
     ScopedVector<HttpAuthHandler> handlers_[HttpAuth::AUTH_NUM_TARGETS];
@@ -94,12 +95,12 @@ class HttpAuthHandlerMock : public HttpAuthHandler {
   virtual bool AllowsExplicitCredentials() OVERRIDE;
 
  protected:
-  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge);
+  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     OldCompletionCallback* callback,
-                                    std::string* auth_token);
+                                    std::string* auth_token) OVERRIDE;
 
  private:
   void OnResolveCanonicalName();
diff --git a/net/http/http_auth_handler_negotiate.h b/net/http/http_auth_handler_negotiate.h
index 8619bf4..2731f5f 100644
--- a/net/http/http_auth_handler_negotiate.h
+++ b/net/http/http_auth_handler_negotiate.h
@@ -70,13 +70,14 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNegotiate : public HttpAuthHandler {
       auth_library_.reset(auth_library);
     }
 
-    virtual int CreateAuthHandler(HttpAuth::ChallengeTokenizer* challenge,
-                                  HttpAuth::Target target,
-                                  const GURL& origin,
-                                  CreateReason reason,
-                                  int digest_nonce_count,
-                                  const BoundNetLog& net_log,
-                                  scoped_ptr<HttpAuthHandler>* handler);
+    virtual int CreateAuthHandler(
+        HttpAuth::ChallengeTokenizer* challenge,
+        HttpAuth::Target target,
+        const GURL& origin,
+        CreateReason reason,
+        int digest_nonce_count,
+        const BoundNetLog& net_log,
+        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
 
    private:
     bool disable_cname_lookup_;
@@ -113,12 +114,12 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNegotiate : public HttpAuthHandler {
   virtual bool AllowsExplicitCredentials() OVERRIDE;
 
  protected:
-  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge);
+  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     OldCompletionCallback* callback,
-                                    std::string* auth_token);
+                                    std::string* auth_token) OVERRIDE;
 
  private:
   enum State {
diff --git a/net/http/http_auth_handler_ntlm.h b/net/http/http_auth_handler_ntlm.h
index 27dcd48..542fd82 100644
--- a/net/http/http_auth_handler_ntlm.h
+++ b/net/http/http_auth_handler_ntlm.h
@@ -42,13 +42,14 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNTLM : public HttpAuthHandler {
     Factory();
     virtual ~Factory();
 
-    virtual int CreateAuthHandler(HttpAuth::ChallengeTokenizer* challenge,
-                                  HttpAuth::Target target,
-                                  const GURL& origin,
-                                  CreateReason reason,
-                                  int digest_nonce_count,
-                                  const BoundNetLog& net_log,
-                                  scoped_ptr<HttpAuthHandler>* handler);
+    virtual int CreateAuthHandler(
+        HttpAuth::ChallengeTokenizer* challenge,
+        HttpAuth::Target target,
+        const GURL& origin,
+        CreateReason reason,
+        int digest_nonce_count,
+        const BoundNetLog& net_log,
+        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
 #if defined(NTLM_SSPI)
     // Set the SSPILibrary to use. Typically the only callers which need to use
     // this are unit tests which pass in a mocked-out version of the SSPI
@@ -104,24 +105,24 @@ class NET_EXPORT_PRIVATE HttpAuthHandlerNTLM : public HttpAuthHandler {
                       URLSecurityManager* url_security_manager);
 #endif
 
-  virtual bool NeedsIdentity();
+  virtual bool NeedsIdentity() OVERRIDE;
 
-  virtual bool AllowsDefaultCredentials();
+  virtual bool AllowsDefaultCredentials() OVERRIDE;
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuth::ChallengeTokenizer* challenge);
+      HttpAuth::ChallengeTokenizer* challenge) OVERRIDE;
 
  protected:
   // This function acquires a credentials handle in the SSPI implementation.
   // It does nothing in the portable implementation.
   int InitializeBeforeFirstChallenge();
 
-  virtual bool Init(HttpAuth::ChallengeTokenizer* tok);
+  virtual bool Init(HttpAuth::ChallengeTokenizer* tok) OVERRIDE;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     OldCompletionCallback* callback,
-                                    std::string* auth_token);
+                                    std::string* auth_token) OVERRIDE;
 
  private:
   virtual ~HttpAuthHandlerNTLM();
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index df464337..526da58 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -109,7 +109,7 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
     // BackendFactory implementation.
     virtual int CreateBackend(NetLog* net_log,
                               disk_cache::Backend** backend,
-                              OldCompletionCallback* callback);
+                              OldCompletionCallback* callback) OVERRIDE;
 
    private:
     CacheType type_;
@@ -191,9 +191,9 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
   void OnExternalCacheHit(const GURL& url, const std::string& http_method);
 
   // HttpTransactionFactory implementation:
-  virtual int CreateTransaction(scoped_ptr<HttpTransaction>* trans);
-  virtual HttpCache* GetCache();
-  virtual HttpNetworkSession* GetSession();
+  virtual int CreateTransaction(scoped_ptr<HttpTransaction>* trans) OVERRIDE;
+  virtual HttpCache* GetCache() OVERRIDE;
+  virtual HttpNetworkSession* GetSession() OVERRIDE;
 
  protected:
   // Disk cache entry data indices.
diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h
index 810c8f9..b6c11c7 100644
--- a/net/http/http_cache_transaction.h
+++ b/net/http/http_cache_transaction.h
@@ -99,19 +99,22 @@ class HttpCache::Transaction : public HttpTransaction {
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, OldCompletionCallback*,
-                    const BoundNetLog&);
-  virtual int RestartIgnoringLastError(OldCompletionCallback* callback);
+                    const BoundNetLog&) OVERRIDE;
+  virtual int RestartIgnoringLastError(
+      OldCompletionCallback* callback) OVERRIDE;
   virtual int RestartWithCertificate(X509Certificate* client_cert,
-                                     OldCompletionCallback* callback);
+                                     OldCompletionCallback* callback) OVERRIDE;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
-                              OldCompletionCallback* callback);
-  virtual bool IsReadyToRestartForAuth();
-  virtual int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual void StopCaching();
-  virtual void DoneReading();
-  virtual const HttpResponseInfo* GetResponseInfo() const;
-  virtual LoadState GetLoadState() const;
-  virtual uint64 GetUploadProgress(void) const;
+                              OldCompletionCallback* callback) OVERRIDE;
+  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual void StopCaching() OVERRIDE;
+  virtual void DoneReading() OVERRIDE;
+  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
+  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual uint64 GetUploadProgress(void) const OVERRIDE;
 
  private:
   static const size_t kNumValidationHeaders = 2;
diff --git a/net/http/http_net_log_params.h b/net/http/http_net_log_params.h
index 1ba94de..daa4770 100644
--- a/net/http/http_net_log_params.h
+++ b/net/http/http_net_log_params.h
@@ -35,7 +35,7 @@ class NetLogHttpRequestParameter : public NetLog::EventParameters {
   }
 
   // NetLog::EventParameters
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   virtual ~NetLogHttpRequestParameter();
@@ -56,7 +56,7 @@ class NetLogHttpResponseParameter : public NetLog::EventParameters {
   }
 
   // NetLog::EventParameters
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   virtual ~NetLogHttpResponseParameter();
diff --git a/net/http/http_network_layer.h b/net/http/http_network_layer.h
index 95f7c95..1fb5b4b 100644
--- a/net/http/http_network_layer.h
+++ b/net/http/http_network_layer.h
@@ -48,13 +48,13 @@ class NET_EXPORT HttpNetworkLayer
   static void EnableSpdy(const std::string& mode);
 
   // HttpTransactionFactory methods:
-  virtual int CreateTransaction(scoped_ptr<HttpTransaction>* trans);
-  virtual HttpCache* GetCache();
-  virtual HttpNetworkSession* GetSession();
+  virtual int CreateTransaction(scoped_ptr<HttpTransaction>* trans) OVERRIDE;
+  virtual HttpCache* GetCache() OVERRIDE;
+  virtual HttpNetworkSession* GetSession() OVERRIDE;
 
   // base::SystemMonitor::PowerObserver methods:
-  virtual void OnSuspend();
-  virtual void OnResume();
+  virtual void OnSuspend() OVERRIDE;
+  virtual void OnResume() OVERRIDE;
 
  private:
   const scoped_refptr<HttpNetworkSession> session_;
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index a2afd84..21bf421 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -44,41 +44,44 @@ class NET_EXPORT_PRIVATE HttpNetworkTransaction
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo* request_info,
                     OldCompletionCallback* callback,
-                    const BoundNetLog& net_log);
-  virtual int RestartIgnoringLastError(OldCompletionCallback* callback);
+                    const BoundNetLog& net_log) OVERRIDE;
+  virtual int RestartIgnoringLastError(
+      OldCompletionCallback* callback) OVERRIDE;
   virtual int RestartWithCertificate(X509Certificate* client_cert,
-                                     OldCompletionCallback* callback);
+                                     OldCompletionCallback* callback) OVERRIDE;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
                               OldCompletionCallback* callback) OVERRIDE;
-  virtual bool IsReadyToRestartForAuth();
+  virtual bool IsReadyToRestartForAuth() OVERRIDE;
 
-  virtual int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual void StopCaching() {}
-  virtual void DoneReading() {}
-  virtual const HttpResponseInfo* GetResponseInfo() const;
-  virtual LoadState GetLoadState() const;
-  virtual uint64 GetUploadProgress() const;
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual void StopCaching() OVERRIDE {}
+  virtual void DoneReading() OVERRIDE {}
+  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
+  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual uint64 GetUploadProgress() const OVERRIDE;
 
   // HttpStreamRequest::Delegate methods:
   virtual void OnStreamReady(const SSLConfig& used_ssl_config,
                              const ProxyInfo& used_proxy_info,
-                             HttpStream* stream);
+                             HttpStream* stream) OVERRIDE;
   virtual void OnStreamFailed(int status,
-                              const SSLConfig& used_ssl_config);
+                              const SSLConfig& used_ssl_config) OVERRIDE;
   virtual void OnCertificateError(int status,
                                   const SSLConfig& used_ssl_config,
-                                  const SSLInfo& ssl_info);
+                                  const SSLInfo& ssl_info) OVERRIDE;
   virtual void OnNeedsProxyAuth(
       const HttpResponseInfo& response_info,
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      HttpAuthController* auth_controller);
+      HttpAuthController* auth_controller) OVERRIDE;
   virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
-                                 SSLCertRequestInfo* cert_info);
+                                 SSLCertRequestInfo* cert_info) OVERRIDE;
   virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
                                           const SSLConfig& used_ssl_config,
                                           const ProxyInfo& used_proxy_info,
-                                          HttpStream* stream);
+                                          HttpStream* stream) OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest, ResetStateForRestart);
diff --git a/net/http/http_proxy_client_socket.h b/net/http/http_proxy_client_socket.h
index 5b85252..def0221 100644
--- a/net/http/http_proxy_client_socket.h
+++ b/net/http/http_proxy_client_socket.h
@@ -64,31 +64,33 @@ class HttpProxyClientSocket : public ProxyClientSocket {
   }
 
   // ProxyClientSocket methods:
-  virtual const HttpResponseInfo* GetConnectResponseInfo() const;
-  virtual HttpStream* CreateConnectResponseStream();
+  virtual const HttpResponseInfo* GetConnectResponseInfo() const OVERRIDE;
+  virtual HttpStream* CreateConnectResponseStream() OVERRIDE;
 
   // StreamSocket methods:
-  virtual int Connect(OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual const BoundNetLog& NetLog() const;
-  virtual void SetSubresourceSpeculation();
-  virtual void SetOmniboxSpeculation();
-  virtual bool WasEverUsed() const;
-  virtual bool UsingTCPFastOpen() const;
-  virtual int64 NumBytesRead() const;
-  virtual base::TimeDelta GetConnectTimeMicros() const;
+  virtual int Connect(OldCompletionCallback* callback) OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool IsConnectedAndIdle() const OVERRIDE;
+  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void SetSubresourceSpeculation() OVERRIDE;
+  virtual void SetOmniboxSpeculation() OVERRIDE;
+  virtual bool WasEverUsed() const OVERRIDE;
+  virtual bool UsingTCPFastOpen() const OVERRIDE;
+  virtual int64 NumBytesRead() const OVERRIDE;
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // Socket methods:
-  virtual int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) const;
+                    OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
+  virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
 
  private:
   enum State {
diff --git a/net/http/http_proxy_client_socket_pool.h b/net/http/http_proxy_client_socket_pool.h
index 66897d2..6fe83dd 100644
--- a/net/http/http_proxy_client_socket_pool.h
+++ b/net/http/http_proxy_client_socket_pool.h
@@ -104,9 +104,9 @@ class HttpProxyConnectJob : public ConnectJob {
   virtual ~HttpProxyConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const;
+  virtual LoadState GetLoadState() const OVERRIDE;
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle* handle);
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE;
 
  private:
   enum State {
@@ -147,7 +147,7 @@ class HttpProxyConnectJob : public ConnectJob {
   // that the tunnel needs authentication credentials, the socket will be
   // returned in this case, and must be release back to the pool; or
   // a standard net error code will be returned.
-  virtual int ConnectInternal();
+  virtual int ConnectInternal() OVERRIDE;
 
   scoped_refptr<HttpProxySocketParams> params_;
   TransportClientSocketPool* const transport_pool_;
@@ -186,39 +186,41 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             OldCompletionCallback* callback,
-                            const BoundNetLog& net_log);
+                            const BoundNetLog& net_log) OVERRIDE;
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log);
+                              const BoundNetLog& net_log) OVERRIDE;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle);
+                             ClientSocketHandle* handle) OVERRIDE;
 
   virtual void ReleaseSocket(const std::string& group_name,
                              StreamSocket* socket,
-                             int id);
+                             int id) OVERRIDE;
 
-  virtual void Flush();
+  virtual void Flush() OVERRIDE;
 
-  virtual void CloseIdleSockets();
+  virtual void CloseIdleSockets() OVERRIDE;
 
-  virtual int IdleSocketCount() const;
+  virtual int IdleSocketCount() const OVERRIDE;
 
-  virtual int IdleSocketCountInGroup(const std::string& group_name) const;
+  virtual int IdleSocketCountInGroup(
+      const std::string& group_name) const OVERRIDE;
 
-  virtual LoadState GetLoadState(const std::string& group_name,
-                                 const ClientSocketHandle* handle) const;
+  virtual LoadState GetLoadState(
+      const std::string& group_name,
+      const ClientSocketHandle* handle) const OVERRIDE;
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const;
+      bool include_nested_pools) const OVERRIDE;
 
-  virtual base::TimeDelta ConnectionTimeout() const;
+  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 
-  virtual ClientSocketPoolHistograms* histograms() const;
+  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
 
  private:
   typedef ClientSocketPoolBase<HttpProxySocketParams> PoolBase;
@@ -232,11 +234,14 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
         NetLog* net_log);
 
     // ClientSocketPoolBase::ConnectJobFactory methods.
-    virtual ConnectJob* NewConnectJob(const std::string& group_name,
-                                      const PoolBase::Request& request,
-                                      ConnectJob::Delegate* delegate) const;
-
-    virtual base::TimeDelta ConnectionTimeout() const { return timeout_; }
+    virtual ConnectJob* NewConnectJob(
+        const std::string& group_name,
+        const PoolBase::Request& request,
+        ConnectJob::Delegate* delegate) const OVERRIDE;
+
+    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+      return timeout_;
+    }
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/http/http_stream_factory_impl.h b/net/http/http_stream_factory_impl.h
index 9c74e23..ce1a04eb 100644
--- a/net/http/http_stream_factory_impl.h
+++ b/net/http/http_stream_factory_impl.h
@@ -32,15 +32,15 @@ class NET_EXPORT_PRIVATE HttpStreamFactoryImpl : public HttpStreamFactory {
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
-      const BoundNetLog& net_log);
+      const BoundNetLog& net_log) OVERRIDE;
 
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  const SSLConfig& server_ssl_config,
                                  const SSLConfig& proxy_ssl_config,
-                                 const BoundNetLog& net_log);
-  virtual void AddTLSIntolerantServer(const HostPortPair& server);
-  virtual bool IsTLSIntolerantServer(const HostPortPair& server) const;
+                                 const BoundNetLog& net_log) OVERRIDE;
+  virtual void AddTLSIntolerantServer(const HostPortPair& server) OVERRIDE;
+  virtual bool IsTLSIntolerantServer(const HostPortPair& server) const OVERRIDE;
 
   // Called when a HttpPipelinedHost has new capacity. Attempts to allocate any
   // pending pipeline-capable requests to pipelines.
diff --git a/net/http/http_stream_factory_impl_request.h b/net/http/http_stream_factory_impl_request.h
index 3a6bcc0..98b2e63 100644
--- a/net/http/http_stream_factory_impl_request.h
+++ b/net/http/http_stream_factory_impl_request.h
@@ -88,10 +88,11 @@ class HttpStreamFactoryImpl::Request : public HttpStreamRequest {
 
   // HttpStreamRequest methods.
 
-  virtual int RestartTunnelWithProxyAuth(const AuthCredentials& credentials);
-  virtual LoadState GetLoadState() const;
-  virtual bool was_npn_negotiated() const;
-  virtual bool using_spdy() const;
+  virtual int RestartTunnelWithProxyAuth(
+      const AuthCredentials& credentials) OVERRIDE;
+  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual bool was_npn_negotiated() const OVERRIDE;
+  virtual bool using_spdy() const OVERRIDE;
 
  private:
   // Used to orphan all jobs in |jobs_| other than |job| which becomes "bound"
diff --git a/net/http/http_stream_parser.h b/net/http/http_stream_parser.h
index 824a238..aa218f8 100644
--- a/net/http/http_stream_parser.h
+++ b/net/http/http_stream_parser.h
@@ -74,7 +74,7 @@ class HttpStreamParser  : public ChunkCallback {
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // ChunkCallback methods.
-  virtual void OnChunkAvailable();
+  virtual void OnChunkAvailable() OVERRIDE;
 
  private:
   // FOO_COMPLETE states implement the second half of potentially asynchronous
diff --git a/net/http/http_transaction_unittest.h b/net/http/http_transaction_unittest.h
index d88b8b3..e4ce1d6 100644
--- a/net/http/http_transaction_unittest.h
+++ b/net/http/http_transaction_unittest.h
@@ -133,7 +133,7 @@ class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > {
   void Read();
 
   // Callback implementation:
-  virtual void RunWithParams(const Tuple1<int>& params);
+  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
 
   State state_;
   scoped_ptr<net::HttpTransaction> trans_;
@@ -211,9 +211,10 @@ class MockNetworkLayer : public net::HttpTransactionFactory,
   void TransactionDoneReading();
 
   // net::HttpTransactionFactory:
-  virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans);
-  virtual net::HttpCache* GetCache();
-  virtual net::HttpNetworkSession* GetSession();
+  virtual int CreateTransaction(
+      scoped_ptr<net::HttpTransaction>* trans) OVERRIDE;
+  virtual net::HttpCache* GetCache() OVERRIDE;
+  virtual net::HttpNetworkSession* GetSession() OVERRIDE;
 
  private:
   int transaction_count_;
diff --git a/net/http/mock_allow_url_security_manager.h b/net/http/mock_allow_url_security_manager.h
index 32f572e..ace9345 100644
--- a/net/http/mock_allow_url_security_manager.h
+++ b/net/http/mock_allow_url_security_manager.h
@@ -17,8 +17,8 @@ class MockAllowURLSecurityManager : public URLSecurityManager {
   MockAllowURLSecurityManager();
   virtual ~MockAllowURLSecurityManager();
 
-  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const;
-  virtual bool CanDelegate(const GURL& auth_origin) const;
+  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const OVERRIDE;
+  virtual bool CanDelegate(const GURL& auth_origin) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAllowURLSecurityManager);
diff --git a/net/http/mock_gssapi_library_posix.h b/net/http/mock_gssapi_library_posix.h
index 4109f9c..84eb348 100644
--- a/net/http/mock_gssapi_library_posix.h
+++ b/net/http/mock_gssapi_library_posix.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -115,32 +115,32 @@ class MockGSSAPILibrary : public GSSAPILibrary {
   // Initializes the library, including any necessary dynamic libraries.
   // This is done separately from construction (which happens at startup time)
   // in order to delay work until the class is actually needed.
-  virtual bool Init();
+  virtual bool Init() OVERRIDE;
 
   // These methods match the ones in the GSSAPI library.
   virtual OM_uint32 import_name(
       OM_uint32* minor_status,
       const gss_buffer_t input_name_buffer,
       const gss_OID input_name_type,
-      gss_name_t* output_name);
+      gss_name_t* output_name) OVERRIDE;
   virtual OM_uint32 release_name(
       OM_uint32* minor_status,
-      gss_name_t* input_name);
+      gss_name_t* input_name) OVERRIDE;
   virtual OM_uint32 release_buffer(
       OM_uint32* minor_status,
-      gss_buffer_t buffer);
+      gss_buffer_t buffer) OVERRIDE;
   virtual OM_uint32 display_name(
       OM_uint32* minor_status,
       const gss_name_t input_name,
       gss_buffer_t output_name_buffer,
-      gss_OID* output_name_type);
+      gss_OID* output_name_type) OVERRIDE;
   virtual OM_uint32 display_status(
       OM_uint32* minor_status,
       OM_uint32 status_value,
       int status_type,
       const gss_OID mech_type,
       OM_uint32* message_contex,
-      gss_buffer_t status_string);
+      gss_buffer_t status_string) OVERRIDE;
   virtual OM_uint32 init_sec_context(
       OM_uint32* minor_status,
       const gss_cred_id_t initiator_cred_handle,
@@ -154,18 +154,18 @@ class MockGSSAPILibrary : public GSSAPILibrary {
       gss_OID* actual_mech_type,
       gss_buffer_t output_token,
       OM_uint32* ret_flags,
-      OM_uint32* time_rec);
+      OM_uint32* time_rec) OVERRIDE;
   virtual OM_uint32 wrap_size_limit(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
       int conf_req_flag,
       gss_qop_t qop_req,
       OM_uint32 req_output_size,
-      OM_uint32* max_input_size);
+      OM_uint32* max_input_size) OVERRIDE;
   virtual OM_uint32 delete_sec_context(
       OM_uint32* minor_status,
       gss_ctx_id_t* context_handle,
-      gss_buffer_t output_token);
+      gss_buffer_t output_token) OVERRIDE;
   virtual OM_uint32 inquire_context(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
@@ -175,7 +175,7 @@ class MockGSSAPILibrary : public GSSAPILibrary {
       gss_OID* mech_type,
       OM_uint32* ctx_flags,
       int* locally_initiated,
-      int* open);
+      int* open) OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpAuthGSSAPIPOSIXTest, GSSAPICycle);
diff --git a/net/http/url_security_manager.h b/net/http/url_security_manager.h
index ce990c6..e95acb3 100644
--- a/net/http/url_security_manager.h
+++ b/net/http/url_security_manager.h
@@ -65,8 +65,8 @@ class URLSecurityManagerWhitelist : public URLSecurityManager {
   virtual ~URLSecurityManagerWhitelist();
 
   // URLSecurityManager methods.
-  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const;
-  virtual bool CanDelegate(const GURL& auth_origin) const;
+  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const OVERRIDE;
+  virtual bool CanDelegate(const GURL& auth_origin) const OVERRIDE;
 
  private:
   scoped_ptr<const HttpAuthFilter> whitelist_default_;