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

89 files changed, 779 insertions, 687 deletions

diff --git a/net/base/address_list_net_log_param.h b/net/base/address_list_net_log_param.h
index 4c621b3..b33fee1 100644
--- a/net/base/address_list_net_log_param.h
+++ b/net/base/address_list_net_log_param.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.
 
@@ -18,7 +18,7 @@ class AddressListNetLogParam : public NetLog::EventParameters {
  public:
   explicit AddressListNetLogParam(const AddressList& address_list);
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   AddressList address_list_;
diff --git a/net/base/cert_verifier.h b/net/base/cert_verifier.h
index ac47196..b937010 100644
--- a/net/base/cert_verifier.h
+++ b/net/base/cert_verifier.h
@@ -183,7 +183,7 @@ class NET_EXPORT CertVerifier : NON_EXPORTED_BASE(public base::NonThreadSafe),
                     const CertVerifyResult& verify_result);
 
   // CertDatabase::Observer methods:
-  virtual void OnCertTrustChanged(const X509Certificate* cert);
+  virtual void OnCertTrustChanged(const X509Certificate* cert) OVERRIDE;
 
   // cache_ maps from a request to a cached result. The cached result may
   // have expired and the size of |cache_| must be <= max_cache_entries_.
diff --git a/net/base/cookie_monster_store_test.h b/net/base/cookie_monster_store_test.h
index 658e9e8..b514ec2 100644
--- a/net/base/cookie_monster_store_test.h
+++ b/net/base/cookie_monster_store_test.h
@@ -128,7 +128,7 @@ class MockCookieMonsterDelegate : public CookieMonster::Delegate {
   virtual void OnCookieChanged(
       const CookieMonster::CanonicalCookie& cookie,
       bool removed,
-      CookieMonster::Delegate::ChangeCause cause);
+      CookieMonster::Delegate::ChangeCause cause) OVERRIDE;
 
  private:
   virtual ~MockCookieMonsterDelegate();
diff --git a/net/base/cookie_store_test_helpers.h b/net/base/cookie_store_test_helpers.h
index e6107c6..ba8c6c8 100644
--- a/net/base/cookie_store_test_helpers.h
+++ b/net/base/cookie_store_test_helpers.h
@@ -28,16 +28,16 @@ class DelayedCookieMonster : public CookieStore {
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const CookieMonster::SetCookiesCallback& callback);
+      const CookieMonster::SetCookiesCallback& callback) OVERRIDE;
 
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url, const CookieOptions& options,
-      const CookieMonster::GetCookiesCallback& callback);
+      const CookieMonster::GetCookiesCallback& callback) OVERRIDE;
 
   virtual void GetCookiesWithInfoAsync(
       const GURL& url,
       const CookieOptions& options,
-      const CookieMonster::GetCookieInfoCallback& callback);
+      const CookieMonster::GetCookieInfoCallback& callback) OVERRIDE;
 
   virtual bool SetCookieWithOptions(const GURL& url,
                                     const std::string& cookie_line,
@@ -56,9 +56,9 @@ class DelayedCookieMonster : public CookieStore {
 
   virtual void DeleteCookieAsync(const GURL& url,
                                  const std::string& cookie_name,
-                                 const base::Closure& callback);
+                                 const base::Closure& callback) OVERRIDE;
 
-  virtual CookieMonster* GetCookieMonster();
+  virtual CookieMonster* GetCookieMonster() OVERRIDE;
 
  private:
 
diff --git a/net/base/dnsrr_resolver.h b/net/base/dnsrr_resolver.h
index c6c5fef..b64fe86 100644
--- a/net/base/dnsrr_resolver.h
+++ b/net/base/dnsrr_resolver.h
@@ -108,7 +108,7 @@ class NET_EXPORT DnsRRResolver
   void CancelResolve(Handle handle);
 
   // Implementation of NetworkChangeNotifier::IPAddressObserver
-  virtual void OnIPAddressChanged();
+  virtual void OnIPAddressChanged() OVERRIDE;
 
  private:
   friend class RRResolverWorker;
diff --git a/net/base/gzip_filter.h b/net/base/gzip_filter.h
index 6da6338..06cabc4 100644
--- a/net/base/gzip_filter.h
+++ b/net/base/gzip_filter.h
@@ -49,7 +49,8 @@ class GZipFilter : public Filter {
   // stream_buffer_. On the other hand, *dest_len can be 0 upon successful
   // return. For example, the internal zlib may process some pre-filter data
   // but not produce output yet.
-  virtual FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len);
+  virtual FilterStatus ReadFilteredData(char* dest_buffer,
+                                        int* dest_len) OVERRIDE;
 
  private:
   enum DecodingStatus {
diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h
index e699ad7..a32cce0 100644
--- a/net/base/host_resolver_impl.h
+++ b/net/base/host_resolver_impl.h
@@ -264,7 +264,7 @@ class NET_EXPORT HostResolverImpl
   void AbortAllInProgressJobs();
 
   // NetworkChangeNotifier::IPAddressObserver methods:
-  virtual void OnIPAddressChanged();
+  virtual void OnIPAddressChanged() OVERRIDE;
 
   // Helper methods to get and set max_retry_attempts_.
   size_t max_retry_attempts() const {
@@ -289,7 +289,7 @@ class NET_EXPORT HostResolverImpl
   }
 
   // NetworkChangeNotifier::OnDNSChanged methods:
-  virtual void OnDNSChanged();
+  virtual void OnDNSChanged() OVERRIDE;
 
   // Cache of host resolution results.
   scoped_ptr<HostCache> cache_;
diff --git a/net/base/listen_socket.h b/net/base/listen_socket.h
index fcf06b9..8223767 100644
--- a/net/base/listen_socket.h
+++ b/net/base/listen_socket.h
@@ -113,8 +113,8 @@ class NET_EXPORT ListenSocket : public base::RefCountedThreadSafe<ListenSocket>,
   HANDLE socket_event_;
 #elif defined(OS_POSIX)
   // Called by MessagePumpLibevent when the socket is ready to do I/O
-  virtual void OnFileCanReadWithoutBlocking(int fd);
-  virtual void OnFileCanWriteWithoutBlocking(int fd);
+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
   WaitState wait_state_;
   // The socket's libevent wrapper
   MessageLoopForIO::FileDescriptorWatcher watcher_;
diff --git a/net/base/listen_socket_unittest.h b/net/base/listen_socket_unittest.h
index 34286a4..1f63bc9 100644
--- a/net/base/listen_socket_unittest.h
+++ b/net/base/listen_socket_unittest.h
@@ -95,9 +95,12 @@ class ListenSocketTester :
   virtual bool Send(SOCKET sock, const std::string& str);
 
   // ListenSocket::ListenSocketDelegate:
-  virtual void DidAccept(ListenSocket *server, ListenSocket *connection);
-  virtual void DidRead(ListenSocket *connection, const char* data, int len);
-  virtual void DidClose(ListenSocket *sock);
+  virtual void DidAccept(ListenSocket *server,
+                         ListenSocket *connection) OVERRIDE;
+  virtual void DidRead(ListenSocket *connection,
+                       const char* data,
+                       int len) OVERRIDE;
+  virtual void DidClose(ListenSocket *sock) OVERRIDE;
 
   scoped_ptr<base::Thread> thread_;
   MessageLoopForIO* loop_;
diff --git a/net/base/mock_filter_context.h b/net/base/mock_filter_context.h
index e04a551..b54e909 100644
--- a/net/base/mock_filter_context.h
+++ b/net/base/mock_filter_context.h
@@ -28,30 +28,30 @@ class MockFilterContext : public FilterContext {
     is_sdch_response_ = is_sdch_response;
   }
 
-  virtual bool GetMimeType(std::string* mime_type) const;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
 
   // What URL was used to access this data?
   // Return false if gurl is not present.
-  virtual bool GetURL(GURL* gurl) const;
+  virtual bool GetURL(GURL* gurl) const OVERRIDE;
 
   // What was this data requested from a server?
-  virtual base::Time GetRequestTime() const;
+  virtual base::Time GetRequestTime() const OVERRIDE;
 
   // Is data supplied from cache, or fresh across the net?
-  virtual bool IsCachedContent() const;
+  virtual bool IsCachedContent() const OVERRIDE;
 
   // Is this a download?
-  virtual bool IsDownload() const;
+  virtual bool IsDownload() const OVERRIDE;
 
   // Was this data flagged as a response to a request with an SDCH dictionary?
-  virtual bool IsSdchResponse() const;
+  virtual bool IsSdchResponse() const OVERRIDE;
 
   // How many bytes were fed to filter(s) so far?
-  virtual int64 GetByteReadCount() const;
+  virtual int64 GetByteReadCount() const OVERRIDE;
 
-  virtual int GetResponseCode() const;
+  virtual int GetResponseCode() const OVERRIDE;
 
-  virtual void RecordPacketStats(StatisticSelector statistic) const {}
+  virtual void RecordPacketStats(StatisticSelector statistic) const OVERRIDE {}
 
  private:
   int buffer_size_;
diff --git a/net/base/mock_host_resolver.h b/net/base/mock_host_resolver.h
index 145b8c0..1aff3cb 100644
--- a/net/base/mock_host_resolver.h
+++ b/net/base/mock_host_resolver.h
@@ -160,7 +160,7 @@ class RuleBasedHostResolverProc : public HostResolverProc {
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error);
+                      int* os_error) OVERRIDE;
 
  private:
   struct Rule;
diff --git a/net/base/net_log.h b/net/base/net_log.h
index 8a5f5ff..5cb8323 100644
--- a/net/base/net_log.h
+++ b/net/base/net_log.h
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/net_export.h"
 
@@ -294,7 +295,7 @@ class NET_EXPORT NetLogStringParameter : public NetLog::EventParameters {
     return value_;
   }
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const char* const name_;
@@ -313,7 +314,7 @@ class NetLogIntegerParameter : public NetLog::EventParameters {
     return value_;
   }
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const char* name_;
@@ -332,7 +333,7 @@ class NET_EXPORT NetLogSourceParameter : public NetLog::EventParameters {
     return value_;
   }
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const char* name_;
diff --git a/net/base/net_test_suite.h b/net/base/net_test_suite.h
index 98c5bd5..feb00dd 100644
--- a/net/base/net_test_suite.h
+++ b/net/base/net_test_suite.h
@@ -22,9 +22,9 @@ class NetTestSuite : public base::TestSuite {
   NetTestSuite(int argc, char** argv);
   virtual ~NetTestSuite();
 
-  virtual void Initialize();
+  virtual void Initialize() OVERRIDE;
 
-  virtual void Shutdown();
+  virtual void Shutdown() OVERRIDE;
 
  protected:
 
diff --git a/net/base/sdch_filter.h b/net/base/sdch_filter.h
index 7fa07ea..606ceb8f 100644
--- a/net/base/sdch_filter.h
+++ b/net/base/sdch_filter.h
@@ -41,7 +41,8 @@ class NET_EXPORT_PRIVATE SdchFilter : public Filter {
   // Upon entry, *dest_len is the total size (in number of chars) of the
   // destination buffer. Upon exit, *dest_len is the actual number of chars
   // written into the destination buffer.
-  virtual FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len);
+  virtual FilterStatus ReadFilteredData(char* dest_buffer,
+                                        int* dest_len) OVERRIDE;
 
  private:
   // Internal status.  Once we enter an error state, we stop processing data.
diff --git a/net/base/ssl_client_auth_cache.h b/net/base/ssl_client_auth_cache.h
index 56e99fe..acaa572 100644
--- a/net/base/ssl_client_auth_cache.h
+++ b/net/base/ssl_client_auth_cache.h
@@ -9,6 +9,7 @@
 #include <string>
 #include <map>
 
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/cert_database.h"
 #include "net/base/net_export.h"
@@ -47,7 +48,7 @@ class NET_EXPORT_PRIVATE SSLClientAuthCache : public CertDatabase::Observer {
   void Remove(const std::string& server);
 
   // CertDatabase::Observer methods:
-  virtual void OnUserCertAdded(const X509Certificate* cert);
+  virtual void OnUserCertAdded(const X509Certificate* cert) OVERRIDE;
 
  private:
   typedef std::string AuthCacheKey;
diff --git a/net/base/ssl_config_service_defaults.h b/net/base/ssl_config_service_defaults.h
index 7312a18..9094db5 100644
--- a/net/base/ssl_config_service_defaults.h
+++ b/net/base/ssl_config_service_defaults.h
@@ -19,7 +19,7 @@ class NET_EXPORT SSLConfigServiceDefaults : public SSLConfigService {
   SSLConfigServiceDefaults();
 
   // Store default SSL config settings in |config|.
-  virtual void GetSSLConfig(SSLConfig* config);
+  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE;
 
  private:
   virtual ~SSLConfigServiceDefaults();
diff --git a/net/base/test_completion_callback.h b/net/base/test_completion_callback.h
index e5135aa..a192194 100644
--- a/net/base/test_completion_callback.h
+++ b/net/base/test_completion_callback.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "base/callback_old.h"
+#include "base/compiler_specific.h"
 #include "base/tuple.h"
 #include "net/base/completion_callback.h"
 
@@ -32,7 +33,7 @@ class TestOldCompletionCallback : public CallbackRunner< Tuple1<int> > {
 
   bool have_result() const { return have_result_; }
 
-  virtual void RunWithParams(const Tuple1<int>& params);
+  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
 
  private:
   int result_;
diff --git a/net/disk_cache/backend_impl.h b/net/disk_cache/backend_impl.h
index a1624dd..1e38678 100644
--- a/net/disk_cache/backend_impl.h
+++ b/net/disk_cache/backend_impl.h
@@ -257,23 +257,24 @@ class NET_EXPORT_PRIVATE BackendImpl : public Backend {
   int SelfCheck();
 
   // Backend interface.
-  virtual int32 GetEntryCount() const;
+  virtual int32 GetEntryCount() const OVERRIDE;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        OldCompletionCallback* callback);
+                        OldCompletionCallback* callback) OVERRIDE;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          OldCompletionCallback* callback);
-  virtual int DoomEntry(const std::string& key, OldCompletionCallback* callback);
-  virtual int DoomAllEntries(OldCompletionCallback* callback);
+                          OldCompletionCallback* callback) OVERRIDE;
+  virtual int DoomEntry(const std::string& key,
+                        OldCompletionCallback* callback) OVERRIDE;
+  virtual int DoomAllEntries(OldCompletionCallback* callback) OVERRIDE;
   virtual int DoomEntriesBetween(const base::Time initial_time,
                                  const base::Time end_time,
-                                 OldCompletionCallback* callback);
+                                 OldCompletionCallback* callback) OVERRIDE;
   virtual int DoomEntriesSince(const base::Time initial_time,
-                               OldCompletionCallback* callback);
+                               OldCompletionCallback* callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
-                            OldCompletionCallback* callback);
-  virtual void EndEnumeration(void** iter);
-  virtual void GetStats(StatsItems* stats);
-  virtual void OnExternalCacheHit(const std::string& key);
+                            OldCompletionCallback* callback) OVERRIDE;
+  virtual void EndEnumeration(void** iter) OVERRIDE;
+  virtual void GetStats(StatsItems* stats) OVERRIDE;
+  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
 
  private:
   typedef base::hash_map<CacheAddr, EntryImpl*> EntriesMap;
diff --git a/net/disk_cache/disk_cache_test_base.h b/net/disk_cache/disk_cache_test_base.h
index 9759a2b..4e1fb12 100644
--- a/net/disk_cache/disk_cache_test_base.h
+++ b/net/disk_cache/disk_cache_test_base.h
@@ -44,7 +44,7 @@ class DiskCacheTest : public PlatformTest {
   // Deletes the contents of |cache_path_|.
   bool CleanupCacheDir();
 
-  virtual void TearDown();
+  virtual void TearDown() OVERRIDE;
 
   FilePath cache_path_;
 
@@ -131,7 +131,7 @@ class DiskCacheTestWithCache : public DiskCacheTest {
   void TrimDeletedListForTest(bool empty);
 
   // DiskCacheTest:
-  virtual void TearDown();
+  virtual void TearDown() OVERRIDE;
 
   // cache_ will always have a valid object, regardless of how the cache was
   // initialized. The implementation pointers can be NULL.
diff --git a/net/disk_cache/disk_cache_test_util.h b/net/disk_cache/disk_cache_test_util.h
index edc090a..4858578 100644
--- a/net/disk_cache/disk_cache_test_util.h
+++ b/net/disk_cache/disk_cache_test_util.h
@@ -112,7 +112,7 @@ class CallbackTest : public CallbackRunner< Tuple1<int> > {
   CallbackTest(MessageLoopHelper* helper, bool reuse);
   virtual ~CallbackTest();
 
-  virtual void RunWithParams(const Tuple1<int>& params);
+  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
 
  private:
   MessageLoopHelper* helper_;
diff --git a/net/disk_cache/entry_impl.h b/net/disk_cache/entry_impl.h
index f76f703..62ec9d7 100644
--- a/net/disk_cache/entry_impl.h
+++ b/net/disk_cache/entry_impl.h
@@ -140,26 +140,30 @@ class NET_EXPORT_PRIVATE EntryImpl
   static int NumBlocksForEntry(int key_size);
 
   // Entry interface.
-  virtual void Doom();
-  virtual void Close();
-  virtual std::string GetKey() const;
-  virtual base::Time GetLastUsed() const;
-  virtual base::Time GetLastModified() const;
-  virtual int32 GetDataSize(int index) const;
-  virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                       net::OldCompletionCallback* completion_callback);
+  virtual void Doom() OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual std::string GetKey() const OVERRIDE;
+  virtual base::Time GetLastUsed() const OVERRIDE;
+  virtual base::Time GetLastModified() const OVERRIDE;
+  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual int ReadData(
+      int index, int offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::OldCompletionCallback* completion_callback,
-                        bool truncate);
-  virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                             net::OldCompletionCallback* completion_callback);
-  virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* completion_callback);
+                        bool truncate) OVERRIDE;
+  virtual int ReadSparseData(
+      int64 offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
+  virtual int WriteSparseData(
+      int64 offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                OldCompletionCallback* callback);
-  virtual bool CouldBeSparse() const;
-  virtual void CancelSparseIO();
-  virtual int ReadyForSparseIO(net::OldCompletionCallback* completion_callback);
+                                OldCompletionCallback* callback) OVERRIDE;
+  virtual bool CouldBeSparse() const OVERRIDE;
+  virtual void CancelSparseIO() OVERRIDE;
+  virtual int ReadyForSparseIO(
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
 
  private:
   enum {
diff --git a/net/disk_cache/in_flight_backend_io.h b/net/disk_cache/in_flight_backend_io.h
index 71ffa38..17efb1a 100644
--- a/net/disk_cache/in_flight_backend_io.h
+++ b/net/disk_cache/in_flight_backend_io.h
@@ -194,7 +194,8 @@ class InFlightBackendIO : public InFlightIO {
   }
 
  protected:
-  virtual void OnOperationComplete(BackgroundIO* operation, bool cancel);
+  virtual void OnOperationComplete(BackgroundIO* operation,
+                                   bool cancel) OVERRIDE;
 
  private:
   void PostOperation(BackendIO* operation);
diff --git a/net/disk_cache/mem_backend_impl.h b/net/disk_cache/mem_backend_impl.h
index 239d7e0..abf1443 100644
--- a/net/disk_cache/mem_backend_impl.h
+++ b/net/disk_cache/mem_backend_impl.h
@@ -8,8 +8,8 @@
 #define NET_DISK_CACHE_MEM_BACKEND_IMPL_H__
 #pragma once
 
+#include "base/compiler_specific.h"
 #include "base/hash_tables.h"
-
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/mem_rankings.h"
 
@@ -63,24 +63,25 @@ class NET_EXPORT_PRIVATE MemBackendImpl : public Backend {
   void RemoveFromRankingList(MemEntryImpl* entry);
 
   // Backend interface.
-  virtual int32 GetEntryCount() const;
+  virtual int32 GetEntryCount() const OVERRIDE;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        OldCompletionCallback* callback);
+                        OldCompletionCallback* callback) OVERRIDE;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          OldCompletionCallback* callback);
-  virtual int DoomEntry(const std::string& key, OldCompletionCallback* callback);
-  virtual int DoomAllEntries(OldCompletionCallback* callback);
+                          OldCompletionCallback* callback) OVERRIDE;
+  virtual int DoomEntry(const std::string& key,
+                        OldCompletionCallback* callback) OVERRIDE;
+  virtual int DoomAllEntries(OldCompletionCallback* callback) OVERRIDE;
   virtual int DoomEntriesBetween(const base::Time initial_time,
                                  const base::Time end_time,
-                                 OldCompletionCallback* callback);
+                                 OldCompletionCallback* callback) OVERRIDE;
   virtual int DoomEntriesSince(const base::Time initial_time,
-                               OldCompletionCallback* callback);
+                               OldCompletionCallback* callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
-                            OldCompletionCallback* callback);
-  virtual void EndEnumeration(void** iter);
+                            OldCompletionCallback* callback) OVERRIDE;
+  virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) {}
-  virtual void OnExternalCacheHit(const std::string& key);
+      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE {}
+  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
 
  private:
   typedef base::hash_map<std::string, MemEntryImpl*> EntryMap;
diff --git a/net/disk_cache/mem_entry_impl.h b/net/disk_cache/mem_entry_impl.h
index 7c4efc4..b1d4703 100644
--- a/net/disk_cache/mem_entry_impl.h
+++ b/net/disk_cache/mem_entry_impl.h
@@ -92,26 +92,30 @@ class MemEntryImpl : public Entry {
   }
 
   // Entry interface.
-  virtual void Doom();
-  virtual void Close();
-  virtual std::string GetKey() const;
-  virtual base::Time GetLastUsed() const;
-  virtual base::Time GetLastModified() const;
-  virtual int32 GetDataSize(int index) const;
-  virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                       net::OldCompletionCallback* completion_callback);
+  virtual void Doom() OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual std::string GetKey() const OVERRIDE;
+  virtual base::Time GetLastUsed() const OVERRIDE;
+  virtual base::Time GetLastModified() const OVERRIDE;
+  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual int ReadData(
+      int index, int offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         net::OldCompletionCallback* completion_callback,
-                        bool truncate);
-  virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                             net::OldCompletionCallback* completion_callback);
-  virtual int WriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* completion_callback);
+                        bool truncate) OVERRIDE;
+  virtual int ReadSparseData(
+      int64 offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
+  virtual int WriteSparseData(
+      int64 offset, net::IOBuffer* buf, int buf_len,
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                OldCompletionCallback* callback);
-  virtual bool CouldBeSparse() const;
-  virtual void CancelSparseIO() {}
-  virtual int ReadyForSparseIO(net::OldCompletionCallback* completion_callback);
+                                OldCompletionCallback* callback) OVERRIDE;
+  virtual bool CouldBeSparse() const OVERRIDE;
+  virtual void CancelSparseIO() OVERRIDE {}
+  virtual int ReadyForSparseIO(
+      net::OldCompletionCallback* completion_callback) OVERRIDE;
 
  private:
   typedef base::hash_map<int, MemEntryImpl*> EntryMap;
diff --git a/net/disk_cache/net_log_parameters.h b/net/disk_cache/net_log_parameters.h
index f248f0f..d0b0c29 100644
--- a/net/disk_cache/net_log_parameters.h
+++ b/net/disk_cache/net_log_parameters.h
@@ -19,7 +19,7 @@ namespace disk_cache {
 class EntryCreationParameters : public net::NetLog::EventParameters {
  public:
   EntryCreationParameters(const std::string& key, bool created);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const std::string key_;
@@ -33,7 +33,7 @@ class ReadWriteDataParameters : public net::NetLog::EventParameters {
  public:
   // For reads, |truncate| must be false.
   ReadWriteDataParameters(int index, int offset, int buf_len, bool truncate);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const int index_;
@@ -51,7 +51,7 @@ class ReadWriteCompleteParameters : public net::NetLog::EventParameters {
   // code.  |bytes_copied| must not be ERR_IO_PENDING, as it's not a valid
   // result for an operation.
   explicit ReadWriteCompleteParameters(int bytes_copied);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const int bytes_copied_;
@@ -63,7 +63,7 @@ class ReadWriteCompleteParameters : public net::NetLog::EventParameters {
 class SparseOperationParameters : public net::NetLog::EventParameters {
  public:
   SparseOperationParameters(int64 offset, int buff_len);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const int64 offset_;
@@ -75,7 +75,7 @@ class SparseOperationParameters : public net::NetLog::EventParameters {
 class SparseReadWriteParameters : public net::NetLog::EventParameters {
  public:
   SparseReadWriteParameters(const net::NetLog::Source& source, int child_len);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const net::NetLog::Source source_;
@@ -87,7 +87,7 @@ class GetAvailableRangeResultParameters : public net::NetLog::EventParameters {
  public:
   // |start| is ignored when |result| < 0.
   GetAvailableRangeResultParameters(int64 start, int result);
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const int64 start_;
diff --git a/net/disk_cache/stats_histogram.h b/net/disk_cache/stats_histogram.h
index 318a8bc..9d44545 100644
--- a/net/disk_cache/stats_histogram.h
+++ b/net/disk_cache/stats_histogram.h
@@ -40,11 +40,12 @@ class StatsHistogram : public base::Histogram {
   // We'll be reporting data from the given set of cache stats.
   bool Init(const Stats* stats);
 
-  virtual Sample ranges(size_t i) const;
-  virtual size_t bucket_count() const;
-  virtual void SnapshotSample(SampleSet* sample) const;
-  virtual Inconsistencies FindCorruption(const SampleSet& snapshot) const;
-  virtual uint32 CalculateRangeChecksum() const;
+  virtual Sample ranges(size_t i) const OVERRIDE;
+  virtual size_t bucket_count() const OVERRIDE;
+  virtual void SnapshotSample(SampleSet* sample) const OVERRIDE;
+  virtual Inconsistencies FindCorruption(
+      const SampleSet& snapshot) const OVERRIDE;
+  virtual uint32 CalculateRangeChecksum() const OVERRIDE;
 
  private:
   bool init_;
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_;
diff --git a/net/server/http_server.h b/net/server/http_server.h
index 1bc24a4..589d887 100644
--- a/net/server/http_server.h
+++ b/net/server/http_server.h
@@ -58,9 +58,11 @@ private:
   friend class HttpConnection;
 
   // ListenSocketDelegate
-  virtual void DidAccept(ListenSocket* server, ListenSocket* socket);
-  virtual void DidRead(ListenSocket* socket, const char* data, int len);
-  virtual void DidClose(ListenSocket* socket);
+  virtual void DidAccept(ListenSocket* server, ListenSocket* socket) OVERRIDE;
+  virtual void DidRead(ListenSocket* socket,
+                       const char* data,
+                       int len) OVERRIDE;
+  virtual void DidClose(ListenSocket* socket) OVERRIDE;
 
   // Expects the raw data to be stored in recv_data_. If parsing is successful,
   // will remove the data parsed from recv_data_, leaving only the unused
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index 9e46e5e..bc098f7 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -311,10 +311,10 @@ class NET_EXPORT_PRIVATE ClientSocketPoolBaseHelper
   void EnableConnectBackupJobs();
 
   // ConnectJob::Delegate methods:
-  virtual void OnConnectJobComplete(int result, ConnectJob* job);
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE;
 
   // NetworkChangeNotifier::IPAddressObserver methods:
-  virtual void OnIPAddressChanged();
+  virtual void OnIPAddressChanged() OVERRIDE;
 
  private:
   friend class base::RefCounted<ClientSocketPoolBaseHelper>;
diff --git a/net/socket/client_socket_pool_manager.h b/net/socket/client_socket_pool_manager.h
index 4829550..1b81781 100644
--- a/net/socket/client_socket_pool_manager.h
+++ b/net/socket/client_socket_pool_manager.h
@@ -172,8 +172,8 @@ class ClientSocketPoolManager : public base::NonThreadSafe,
   base::Value* SocketPoolInfoToValue() const;
 
   // CertDatabase::Observer methods:
-  virtual void OnUserCertAdded(const X509Certificate* cert);
-  virtual void OnCertTrustChanged(const X509Certificate* cert);
+  virtual void OnUserCertAdded(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertTrustChanged(const X509Certificate* cert) OVERRIDE;
 
  private:
   friend class HttpNetworkSessionPeer;
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index cc90516..e1d2b2a 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -199,9 +199,9 @@ class StaticSocketDataProvider : public SocketDataProvider {
   virtual void CompleteRead() {}
 
   // SocketDataProvider methods:
-  virtual MockRead GetNextRead();
-  virtual MockWriteResult OnWrite(const std::string& data);
-  virtual void Reset();
+  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
+  virtual void Reset() OVERRIDE;
 
  private:
   MockRead* reads_;
@@ -229,9 +229,9 @@ class DynamicSocketDataProvider : public SocketDataProvider {
   void allow_unconsumed_reads(bool allow) { allow_unconsumed_reads_ = allow; }
 
   // SocketDataProvider methods:
-  virtual MockRead GetNextRead();
+  virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
-  virtual void Reset();
+  virtual void Reset() OVERRIDE;
 
  protected:
   // The next time there is a read from this socket, it will return |data|.
@@ -301,10 +301,10 @@ class DelayedSocketData : public StaticSocketDataProvider,
   void ForceNextRead();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead();
-  virtual MockWriteResult OnWrite(const std::string& data);
-  virtual void Reset();
-  virtual void CompleteRead();
+  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
+  virtual void Reset() OVERRIDE;
+  virtual void CompleteRead() OVERRIDE;
 
  private:
   int write_delay_;
@@ -351,10 +351,10 @@ class OrderedSocketData : public StaticSocketDataProvider,
   void EndLoop();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead();
-  virtual MockWriteResult OnWrite(const std::string& data);
-  virtual void Reset();
-  virtual void CompleteRead();
+  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
+  virtual void Reset() OVERRIDE;
+  virtual void CompleteRead() OVERRIDE;
 
  private:
   friend class base::RefCounted<OrderedSocketData>;
@@ -459,14 +459,14 @@ class DeterministicSocketData : public StaticSocketDataProvider,
 
   // When the socket calls Read(), that calls GetNextRead(), and expects either
   // ERR_IO_PENDING or data.
-  virtual MockRead GetNextRead();
+  virtual MockRead GetNextRead() OVERRIDE;
 
   // When the socket calls Write(), it always completes synchronously. OnWrite()
   // checks to make sure the written data matches the expected data. The
   // callback will not be invoked until its sequence number is reached.
-  virtual MockWriteResult OnWrite(const std::string& data);
-  virtual void Reset();
-  virtual void CompleteRead() {}
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
+  virtual void Reset() OVERRIDE;
+  virtual void CompleteRead() OVERRIDE {}
 
  private:
   // Invoke the read and write callbacks, if the timing is appropriate.
@@ -556,18 +556,18 @@ class MockClientSocketFactory : public ClientSocketFactory {
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source);
+      const NetLog::Source& source) OVERRIDE;
   virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source);
+      const NetLog::Source& source) OVERRIDE;
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
-      const SSLClientSocketContext& context);
-  virtual void ClearSSLSessionCache();
+      const SSLClientSocketContext& context) OVERRIDE;
+  virtual void ClearSSLSessionCache() OVERRIDE;
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
@@ -588,29 +588,29 @@ class MockClientSocket : public net::SSLClientSocket {
                    net::OldCompletionCallback* callback) = 0;
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     net::OldCompletionCallback* callback) = 0;
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // StreamSocket methods:
   virtual int Connect(net::OldCompletionCallback* callback) = 0;
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) const;
-  virtual const BoundNetLog& NetLog() const;
-  virtual void SetSubresourceSpeculation() {}
-  virtual void SetOmniboxSpeculation() {}
+  virtual void Disconnect() OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool IsConnectedAndIdle() const OVERRIDE;
+  virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void SetSubresourceSpeculation() OVERRIDE {}
+  virtual void SetOmniboxSpeculation() OVERRIDE {}
 
   // SSLClientSocket methods:
-  virtual void GetSSLInfo(net::SSLInfo* ssl_info);
+  virtual void GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
   virtual void GetSSLCertRequestInfo(
-      net::SSLCertRequestInfo* cert_request_info);
+      net::SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    const base::StringPiece& context,
                                    unsigned char *out,
-                                   unsigned int outlen);
-  virtual NextProtoStatus GetNextProto(std::string* proto);
+                                   unsigned int outlen) OVERRIDE;
+  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
 
  protected:
   virtual ~MockClientSocket();
@@ -634,23 +634,23 @@ class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback);
+                   net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback);
+                    net::OldCompletionCallback* callback) OVERRIDE;
 
   // StreamSocket methods:
-  virtual int Connect(net::OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual bool WasEverUsed() const;
-  virtual bool UsingTCPFastOpen() const;
-  virtual int64 NumBytesRead() const;
-  virtual base::TimeDelta GetConnectTimeMicros() const;
+  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool IsConnectedAndIdle() const OVERRIDE;
+  virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual bool WasEverUsed() const OVERRIDE;
+  virtual bool UsingTCPFastOpen() const OVERRIDE;
+  virtual int64 NumBytesRead() const OVERRIDE;
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data);
+  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   int CompleteRead();
@@ -691,22 +691,22 @@ class DeterministicMockTCPClientSocket : public MockClientSocket,
 
   // Socket:
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback);
+                    net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback);
+                   net::OldCompletionCallback* callback) OVERRIDE;
 
   // StreamSocket:
-  virtual int Connect(net::OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual bool WasEverUsed() const;
-  virtual bool UsingTCPFastOpen() const;
-  virtual int64 NumBytesRead() const;
-  virtual base::TimeDelta GetConnectTimeMicros() const;
+  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool IsConnectedAndIdle() const OVERRIDE;
+  virtual bool WasEverUsed() const OVERRIDE;
+  virtual bool UsingTCPFastOpen() const OVERRIDE;
+  virtual int64 NumBytesRead() const OVERRIDE;
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data);
+  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   bool write_pending_;
@@ -735,29 +735,29 @@ class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
 
   // Socket methods:
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback);
+                   net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback);
+                    net::OldCompletionCallback* callback) OVERRIDE;
 
   // StreamSocket methods:
-  virtual int Connect(net::OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool WasEverUsed() const;
-  virtual bool UsingTCPFastOpen() const;
-  virtual int64 NumBytesRead() const;
-  virtual base::TimeDelta GetConnectTimeMicros() const;
+  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
+  virtual void Disconnect() OVERRIDE;
+  virtual bool IsConnected() const OVERRIDE;
+  virtual bool WasEverUsed() const OVERRIDE;
+  virtual bool UsingTCPFastOpen() const OVERRIDE;
+  virtual int64 NumBytesRead() const OVERRIDE;
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE;
 
   // SSLClientSocket methods:
-  virtual void GetSSLInfo(net::SSLInfo* ssl_info);
+  virtual void GetSSLInfo(net::SSLInfo* ssl_info) OVERRIDE;
   virtual void GetSSLCertRequestInfo(
-      net::SSLCertRequestInfo* cert_request_info);
-  virtual NextProtoStatus GetNextProto(std::string* proto);
-  virtual bool was_npn_negotiated() const;
-  virtual bool set_was_npn_negotiated(bool negotiated);
+      net::SSLCertRequestInfo* cert_request_info) OVERRIDE;
+  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
+  virtual bool was_npn_negotiated() const OVERRIDE;
+  virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
 
   // This MockSocket does not implement the manual async IO feature.
-  virtual void OnReadComplete(const MockRead& data);
+  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   class ConnectCallback;
@@ -777,23 +777,23 @@ class MockUDPClientSocket : public DatagramClientSocket,
 
   // Socket interface
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback);
+                   net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+                    net::OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // DatagramSocket interface
-  virtual void Close();
-  virtual int GetPeerAddress(IPEndPoint* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) const;
-  virtual const BoundNetLog& NetLog() const;
+  virtual void Close() OVERRIDE;
+  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual const BoundNetLog& NetLog() const OVERRIDE;
 
   // DatagramClientSocket interface
-  virtual int Connect(const IPEndPoint& address);
+  virtual int Connect(const IPEndPoint& address) OVERRIDE;
 
   // AsyncSocket interface
-  virtual void OnReadComplete(const MockRead& data);
+  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
 
  private:
   int CompleteRead();
@@ -829,7 +829,7 @@ class TestSocketRequest : public CallbackRunner< Tuple1<int> > {
   ClientSocketHandle* handle() { return &handle_; }
 
   int WaitForResult();
-  virtual void RunWithParams(const Tuple1<int>& params);
+  virtual void RunWithParams(const Tuple1<int>& params) OVERRIDE;
 
  private:
   ClientSocketHandle handle_;
@@ -933,12 +933,12 @@ class MockTransportClientSocketPool : public TransportClientSocketPool {
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             OldCompletionCallback* callback,
-                            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);
+                             StreamSocket* socket, int id) OVERRIDE;
 
  private:
   ClientSocketFactory* client_socket_factory_;
@@ -974,18 +974,18 @@ class DeterministicMockClientSocketFactory : public ClientSocketFactory {
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source);
+      const NetLog::Source& source) OVERRIDE;
   virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source);
+      const NetLog::Source& source) OVERRIDE;
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
-      const SSLClientSocketContext& context);
-  virtual void ClearSSLSessionCache();
+      const SSLClientSocketContext& context) OVERRIDE;
+  virtual void ClearSSLSessionCache() OVERRIDE;
 
  private:
   SocketDataProviderArray<DeterministicSocketData> mock_data_;
@@ -1012,12 +1012,12 @@ class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             OldCompletionCallback* callback,
-                            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);
+                             StreamSocket* socket, int id) OVERRIDE;
 
  private:
   TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/socks5_client_socket.h b/net/socket/socks5_client_socket.h
index 03b17f2..aeb1864 100644
--- a/net/socket/socks5_client_socket.h
+++ b/net/socket/socks5_client_socket.h
@@ -51,27 +51,31 @@ class NET_EXPORT_PRIVATE SOCKS5ClientSocket : public StreamSocket {
   // StreamSocket methods:
 
   // Does the SOCKS handshake and completes the protocol.
-  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 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;
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    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/socket/socks_client_socket.h b/net/socket/socks_client_socket.h
index 442db90..eb74a5e 100644
--- a/net/socket/socks_client_socket.h
+++ b/net/socket/socks_client_socket.h
@@ -48,27 +48,31 @@ class NET_EXPORT_PRIVATE SOCKSClientSocket : public StreamSocket {
   // StreamSocket methods:
 
   // Does the SOCKS handshake and completes the protocol.
-  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 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;
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    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:
   FRIEND_TEST_ALL_PREFIXES(SOCKSClientSocketTest, CompleteHandshake);
diff --git a/net/socket/socks_client_socket_pool.h b/net/socket/socks_client_socket_pool.h
index 741e0a3..34352b48 100644
--- a/net/socket/socks_client_socket_pool.h
+++ b/net/socket/socks_client_socket_pool.h
@@ -67,7 +67,7 @@ class SOCKSConnectJob : public ConnectJob {
   virtual ~SOCKSConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const;
+  virtual LoadState GetLoadState() const OVERRIDE;
 
  private:
   enum State {
@@ -91,7 +91,7 @@ class SOCKSConnectJob : public ConnectJob {
   // Begins the transport connection and the SOCKS handshake.  Returns OK on
   // success and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal();
+  virtual int ConnectInternal() OVERRIDE;
 
   scoped_refptr<SOCKSSocketParams> socks_params_;
   TransportClientSocketPool* const transport_pool_;
@@ -123,39 +123,41 @@ class NET_EXPORT_PRIVATE SOCKSClientSocketPool : 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<SOCKSSocketParams> PoolBase;
@@ -175,9 +177,9 @@ class NET_EXPORT_PRIVATE SOCKSClientSocketPool : public ClientSocketPool {
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const;
+        ConnectJob::Delegate* delegate) const OVERRIDE;
 
-    virtual base::TimeDelta ConnectionTimeout() const;
+    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/ssl_client_socket_mac.h b/net/socket/ssl_client_socket_mac.h
index 5370b2d..febf072 100644
--- a/net/socket/ssl_client_socket_mac.h
+++ b/net/socket/ssl_client_socket_mac.h
@@ -41,34 +41,39 @@ class SSLClientSocketMac : public SSLClientSocket {
   virtual ~SSLClientSocketMac();
 
   // SSLClientSocket methods:
-  virtual void GetSSLInfo(SSLInfo* ssl_info);
-  virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
+  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLCertRequestInfo(
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    const base::StringPiece& context,
                                    unsigned char *out,
-                                   unsigned int outlen);
-  virtual NextProtoStatus GetNextProto(std::string* proto);
+                                   unsigned int outlen) OVERRIDE;
+  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
 
   // StreamSocket methods:
-  virtual int Connect(OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) 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 int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) 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 Write(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
  private:
   bool completed_handshake() const {
diff --git a/net/socket/ssl_client_socket_nss.h b/net/socket/ssl_client_socket_nss.h
index 648e249..f7def8c 100644
--- a/net/socket/ssl_client_socket_nss.h
+++ b/net/socket/ssl_client_socket_nss.h
@@ -60,34 +60,39 @@ class SSLClientSocketNSS : public SSLClientSocket {
   static void ClearSessionCache();
 
   // SSLClientSocket methods:
-  virtual void GetSSLInfo(SSLInfo* ssl_info);
-  virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
+  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLCertRequestInfo(
+      SSLCertRequestInfo* cert_request_info) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    const base::StringPiece& context,
                                    unsigned char *out,
-                                   unsigned int outlen);
-  virtual NextProtoStatus GetNextProto(std::string* proto);
+                                   unsigned int outlen) OVERRIDE;
+  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
 
   // StreamSocket methods:
-  virtual int Connect(OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) 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 int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) 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 Write(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
  private:
   enum State {
diff --git a/net/socket/ssl_client_socket_pool.h b/net/socket/ssl_client_socket_pool.h
index 2437a55..3305a6f 100644
--- a/net/socket/ssl_client_socket_pool.h
+++ b/net/socket/ssl_client_socket_pool.h
@@ -106,9 +106,9 @@ class SSLConnectJob : public ConnectJob {
   virtual ~SSLConnectJob();
 
   // 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 {
@@ -140,7 +140,7 @@ class SSLConnectJob : public ConnectJob {
   // Starts the SSL connection process.  Returns OK on success and
   // ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal();
+  virtual int ConnectInternal() OVERRIDE;
 
   scoped_refptr<SSLSocketParams> params_;
   TransportClientSocketPool* const transport_pool_;
@@ -196,39 +196,41 @@ class NET_EXPORT_PRIVATE SSLClientSocketPool
                             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<SSLSocketParams> PoolBase;
@@ -237,7 +239,7 @@ class NET_EXPORT_PRIVATE SSLClientSocketPool
 
   // When the user changes the SSL config, we flush all idle sockets so they
   // won't get re-used.
-  virtual void OnSSLConfigChanged();
+  virtual void OnSSLConfigChanged() OVERRIDE;
 
   class SSLConnectJobFactory : public PoolBase::ConnectJobFactory {
    public:
@@ -256,9 +258,11 @@ class NET_EXPORT_PRIVATE SSLClientSocketPool
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const;
+        ConnectJob::Delegate* delegate) const OVERRIDE;
 
-    virtual base::TimeDelta ConnectionTimeout() const { return timeout_; }
+    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+      return timeout_;
+    }
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/ssl_error_params.h b/net/socket/ssl_error_params.h
index c0d685a..434d8bc 100644
--- a/net/socket/ssl_error_params.h
+++ b/net/socket/ssl_error_params.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.
 
@@ -16,7 +16,7 @@ class SSLErrorParams : public NetLog::EventParameters {
   SSLErrorParams(int net_error, int ssl_lib_error);
   virtual ~SSLErrorParams();
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const int net_error_;
diff --git a/net/socket/ssl_server_socket_nss.h b/net/socket/ssl_server_socket_nss.h
index 980464d..0004c4a 100644
--- a/net/socket/ssl_server_socket_nss.h
+++ b/net/socket/ssl_server_socket_nss.h
@@ -32,34 +32,34 @@ class SSLServerSocketNSS : public SSLServerSocket {
   virtual ~SSLServerSocketNSS();
 
   // SSLServerSocket interface.
-  virtual int Handshake(OldCompletionCallback* callback);
+  virtual int Handshake(OldCompletionCallback* callback) OVERRIDE;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    const base::StringPiece& context,
                                    unsigned char *out,
-                                   unsigned int outlen);
+                                   unsigned int outlen) OVERRIDE;
 
   // Socket interface (via StreamSocket).
   virtual int Read(IOBuffer* buf, int buf_len,
-                   OldCompletionCallback* callback);
+                   OldCompletionCallback* callback) OVERRIDE;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+                    OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // StreamSocket interface.
-  virtual int Connect(OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) 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 int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) 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;
 
  private:
   enum State {
diff --git a/net/socket/tcp_client_socket_libevent.h b/net/socket/tcp_client_socket_libevent.h
index 3baf6c9..2a6b041 100644
--- a/net/socket/tcp_client_socket_libevent.h
+++ b/net/socket/tcp_client_socket_libevent.h
@@ -43,27 +43,31 @@ class NET_EXPORT_PRIVATE TCPClientSocketLibevent : public StreamSocket,
   int Bind(const IPEndPoint& address);
 
   // StreamSocket methods:
-  virtual int Connect(OldCompletionCallback* callback);
-  virtual void Disconnect();
-  virtual bool IsConnected() const;
-  virtual bool IsConnectedAndIdle() const;
-  virtual int GetPeerAddress(AddressList* address) const;
-  virtual int GetLocalAddress(IPEndPoint* address) 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 int GetPeerAddress(AddressList* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) 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:
   // Multiple outstanding requests are not supported.
   // Full duplex mode (reading and writing at the same time) is supported
-  virtual int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual int Write(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
-  virtual bool SetReceiveBufferSize(int32 size);
-  virtual bool SetSendBufferSize(int32 size);
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   OldCompletionCallback* callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    OldCompletionCallback* callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
  private:
   // State machine for connecting the socket.
@@ -79,12 +83,12 @@ class NET_EXPORT_PRIVATE TCPClientSocketLibevent : public StreamSocket,
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
       if (socket_->read_callback_)
         socket_->DidCompleteRead();
     }
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {}
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {}
 
    private:
     TCPClientSocketLibevent* const socket_;
@@ -98,9 +102,9 @@ class NET_EXPORT_PRIVATE TCPClientSocketLibevent : public StreamSocket,
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {}
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {}
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
       if (socket_->waiting_connect()) {
         socket_->DidCompleteConnect();
       } else if (socket_->write_callback_) {
diff --git a/net/socket/tcp_server_socket_libevent.h b/net/socket/tcp_server_socket_libevent.h
index df846b2..1325d06 100644
--- a/net/socket/tcp_server_socket_libevent.h
+++ b/net/socket/tcp_server_socket_libevent.h
@@ -26,14 +26,14 @@ class NET_EXPORT_PRIVATE TCPServerSocketLibevent
   virtual ~TCPServerSocketLibevent();
 
   // net::ServerSocket implementation.
-  virtual int Listen(const net::IPEndPoint& address, int backlog);
-  virtual int GetLocalAddress(IPEndPoint* address) const;
+  virtual int Listen(const net::IPEndPoint& address, int backlog) OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     OldCompletionCallback* callback);
+                     OldCompletionCallback* callback) OVERRIDE;
 
   // MessageLoopForIO::Watcher implementation.
-  virtual void OnFileCanReadWithoutBlocking(int fd);
-  virtual void OnFileCanWriteWithoutBlocking(int fd);
+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
  private:
   int AcceptInternal(scoped_ptr<StreamSocket>* socket);
diff --git a/net/socket/transport_client_socket_pool.h b/net/socket/transport_client_socket_pool.h
index e343371b..055fae1 100644
--- a/net/socket/transport_client_socket_pool.h
+++ b/net/socket/transport_client_socket_pool.h
@@ -67,7 +67,7 @@ class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
   virtual ~TransportConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const;
+  virtual LoadState GetLoadState() const OVERRIDE;
 
   // Makes |addrlist| start with an IPv4 address if |addrlist| contains any
   // IPv4 address.
@@ -104,7 +104,7 @@ class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
   // Begins the host resolution and the TCP connect.  Returns OK on success
   // and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal();
+  virtual int ConnectInternal() OVERRIDE;
 
   scoped_refptr<TransportSocketParams> params_;
   ClientSocketFactory* const client_socket_factory_;
@@ -149,39 +149,41 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool : 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<TransportSocketParams> PoolBase;
@@ -203,9 +205,9 @@ class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool {
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const;
+        ConnectJob::Delegate* delegate) const OVERRIDE;
 
-    virtual base::TimeDelta ConnectionTimeout() const;
+    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 
    private:
     ClientSocketFactory* const client_socket_factory_;
diff --git a/net/spdy/spdy_http_stream.h b/net/spdy/spdy_http_stream.h
index b025cd2..2d25f17 100644
--- a/net/spdy/spdy_http_stream.h
+++ b/net/spdy/spdy_http_stream.h
@@ -53,7 +53,7 @@ class NET_EXPORT_PRIVATE SpdyHttpStream : public SpdyStream::Delegate,
                           OldCompletionCallback* callback) OVERRIDE;
   virtual uint64 GetUploadProgress() const OVERRIDE;
   virtual int ReadResponseHeaders(OldCompletionCallback* callback) OVERRIDE;
-  virtual const HttpResponseInfo* GetResponseInfo() const;
+  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
                                OldCompletionCallback* callback) OVERRIDE;
diff --git a/net/spdy/spdy_proxy_client_socket.h b/net/spdy/spdy_proxy_client_socket.h
index 936efdb..8a9237b 100644
--- a/net/spdy/spdy_proxy_client_socket.h
+++ b/net/spdy/spdy_proxy_client_socket.h
@@ -58,47 +58,49 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
   }
 
   // ProxyClientSocket methods:
-  virtual const HttpResponseInfo* GetConnectResponseInfo() const;
+  virtual const HttpResponseInfo* GetConnectResponseInfo() const OVERRIDE;
 
   // In the event of a non-200 response to the CONNECT request, this
   // method may be called to return an HttpStream in order to read
   // the response body.
-  virtual HttpStream* CreateConnectResponseStream();
+  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;
 
   // SpdyStream::Delegate methods:
-  virtual bool OnSendHeadersComplete(int status);
-  virtual int OnSendBody();
-  virtual int OnSendBodyComplete(int status, bool* eof);
+  virtual bool OnSendHeadersComplete(int status) OVERRIDE;
+  virtual int OnSendBody() OVERRIDE;
+  virtual int OnSendBodyComplete(int status, bool* eof) OVERRIDE;
   virtual int OnResponseReceived(const spdy::SpdyHeaderBlock& response,
                                  base::Time response_time,
-                                 int status);
-  virtual void OnDataReceived(const char* data, int length);
-  virtual void OnDataSent(int length);
-  virtual void OnClose(int status);
-  virtual void set_chunk_callback(ChunkCallback* /*callback*/);
+                                 int status) OVERRIDE;
+  virtual void OnDataReceived(const char* data, int length) OVERRIDE;
+  virtual void OnDataSent(int length) OVERRIDE;
+  virtual void OnClose(int status) OVERRIDE;
+  virtual void set_chunk_callback(ChunkCallback* /*callback*/) OVERRIDE;
 
  private:
   enum State {
diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h
index 8d9b8ae..b5b7dc7 100644
--- a/net/spdy/spdy_session.h
+++ b/net/spdy/spdy_session.h
@@ -380,17 +380,17 @@ class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>,
   void InvokeUserStreamCreationCallback(scoped_refptr<SpdyStream>* stream);
 
   // SpdyFramerVisitorInterface:
-  virtual void OnError(spdy::SpdyFramer*);
+  virtual void OnError(spdy::SpdyFramer*) OVERRIDE;
   virtual void OnStreamFrameData(spdy::SpdyStreamId stream_id,
                                  const char* data,
-                                 size_t len);
-  virtual void OnControl(const spdy::SpdyControlFrame* frame);
+                                 size_t len) OVERRIDE;
+  virtual void OnControl(const spdy::SpdyControlFrame* frame) OVERRIDE;
 
   virtual bool OnControlFrameHeaderData(spdy::SpdyStreamId stream_id,
                                         const char* header_data,
-                                        size_t len);
+                                        size_t len) OVERRIDE;
 
-  virtual void OnDataFrameHeader(const spdy::SpdyDataFrame* frame);
+  virtual void OnDataFrameHeader(const spdy::SpdyDataFrame* frame) OVERRIDE;
 
   // --------------------------
   // Helper methods for testing
@@ -603,7 +603,7 @@ class NetLogSpdySynParameter : public NetLog::EventParameters {
     return headers_;
   }
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   virtual ~NetLogSpdySynParameter();
diff --git a/net/spdy/spdy_session_pool.h b/net/spdy/spdy_session_pool.h
index 3861481..93ddf22 100644
--- a/net/spdy/spdy_session_pool.h
+++ b/net/spdy/spdy_session_pool.h
@@ -116,12 +116,12 @@ class NET_EXPORT SpdySessionPool
   // We flush all idle sessions and release references to the active ones so
   // they won't get re-used.  The active ones will either complete successfully
   // or error out due to the IP address change.
-  virtual void OnIPAddressChanged();
+  virtual void OnIPAddressChanged() OVERRIDE;
 
   // SSLConfigService::Observer methods:
 
   // We perform the same flushing as described above when SSL settings change.
-  virtual void OnSSLConfigChanged();
+  virtual void OnSSLConfigChanged() OVERRIDE;
 
   // A debugging mode where we compress all accesses through a single domain.
   static void ForceSingleDomain() { g_force_single_domain = true; }
@@ -131,8 +131,8 @@ class NET_EXPORT SpdySessionPool
   static void enable_ip_pooling(bool value) { g_enable_ip_pooling = value; }
 
   // CertDatabase::Observer methods:
-  virtual void OnUserCertAdded(const X509Certificate* cert);
-  virtual void OnCertTrustChanged(const X509Certificate* cert);
+  virtual void OnUserCertAdded(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertTrustChanged(const X509Certificate* cert) OVERRIDE;
 
  private:
   friend class SpdySessionPoolPeer;  // For testing.
diff --git a/net/spdy/spdy_stream.h b/net/spdy/spdy_stream.h
index f7e8699..865fd23 100644
--- a/net/spdy/spdy_stream.h
+++ b/net/spdy/spdy_stream.h
@@ -234,7 +234,7 @@ class NET_EXPORT_PRIVATE SpdyStream
   GURL GetUrl() const;
 
   // ChunkCallback methods.
-  virtual void OnChunkAvailable();
+  virtual void OnChunkAvailable() OVERRIDE;
 
  private:
   enum State {
diff --git a/net/spdy/spdy_websocket_stream.h b/net/spdy/spdy_websocket_stream.h
index 686e7ca..1f0839e 100644
--- a/net/spdy/spdy_websocket_stream.h
+++ b/net/spdy/spdy_websocket_stream.h
@@ -69,16 +69,16 @@ class NET_EXPORT_PRIVATE SpdyWebSocketStream
   void Close();
 
   // SpdyStream::Delegate
-  virtual bool OnSendHeadersComplete(int status);
-  virtual int OnSendBody();
-  virtual int OnSendBodyComplete(int status, bool* eof);
+  virtual bool OnSendHeadersComplete(int status) OVERRIDE;
+  virtual int OnSendBody() OVERRIDE;
+  virtual int OnSendBodyComplete(int status, bool* eof) OVERRIDE;
   virtual int OnResponseReceived(const spdy::SpdyHeaderBlock& response,
                                  base::Time response_time,
-                                 int status);
-  virtual void OnDataReceived(const char* data, int length);
-  virtual void OnDataSent(int length);
-  virtual void OnClose(int status);
-  virtual void set_chunk_callback(ChunkCallback* callback);
+                                 int status) OVERRIDE;
+  virtual void OnDataReceived(const char* data, int length) OVERRIDE;
+  virtual void OnDataSent(int length) OVERRIDE;
+  virtual void OnClose(int status) OVERRIDE;
+  virtual void set_chunk_callback(ChunkCallback* callback) OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SpdyWebSocketStreamTest, Basic);
diff --git a/net/tools/fetch/http_listen_socket.h b/net/tools/fetch/http_listen_socket.h
index 4d20e1d..18e3a46 100644
--- a/net/tools/fetch/http_listen_socket.h
+++ b/net/tools/fetch/http_listen_socket.h
@@ -28,8 +28,8 @@ class HttpListenSocket : public net::ListenSocket,
   static HttpListenSocket* Listen(const std::string& ip, int port,
                                   HttpListenSocket::Delegate* delegate);
 
-  virtual void Listen();
-  virtual void Accept();
+  virtual void Listen() OVERRIDE;
+  virtual void Accept() OVERRIDE;
 
   // Send a server response.
   // TODO(mbelshe): make this capable of non-ascii data.
@@ -37,10 +37,10 @@ class HttpListenSocket : public net::ListenSocket,
 
   // ListenSocketDelegate
   virtual void DidAccept(net::ListenSocket* server,
-                         net::ListenSocket* connection);
+                         net::ListenSocket* connection) OVERRIDE;
   virtual void DidRead(net::ListenSocket* connection,
-                       const char* data, int len);
-  virtual void DidClose(net::ListenSocket* sock);
+                       const char* data, int len) OVERRIDE;
+  virtual void DidClose(net::ListenSocket* sock) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<net::ListenSocket>;
diff --git a/net/tools/fetch/http_session.h b/net/tools/fetch/http_session.h
index b4b582c..ec613c1 100644
--- a/net/tools/fetch/http_session.h
+++ b/net/tools/fetch/http_session.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.
 
@@ -17,7 +17,7 @@ class HttpSession : HttpListenSocket::Delegate {
   virtual ~HttpSession();
 
   virtual void OnRequest(HttpListenSocket* connection,
-                         HttpServerRequestInfo* info);
+                         HttpServerRequestInfo* info) OVERRIDE;
 
  private:
   scoped_refptr<HttpListenSocket> socket_;
diff --git a/net/udp/udp_socket_libevent.h b/net/udp/udp_socket_libevent.h
index abc2dd5..1b823c76 100644
--- a/net/udp/udp_socket_libevent.h
+++ b/net/udp/udp_socket_libevent.h
@@ -113,12 +113,12 @@ class UDPSocketLibevent : public base::NonThreadSafe {
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
       if (socket_->read_callback_)
         socket_->DidCompleteRead();
     }
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {}
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {}
 
    private:
     UDPSocketLibevent* const socket_;
@@ -132,9 +132,9 @@ class UDPSocketLibevent : public base::NonThreadSafe {
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {}
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {}
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {
       if (socket_->write_callback_)
         socket_->DidCompleteWrite();
     }
diff --git a/net/url_request/url_request_about_job.h b/net/url_request/url_request_about_job.h
index 461b9e4..55f0478 100644
--- a/net/url_request/url_request_about_job.h
+++ b/net/url_request/url_request_about_job.h
@@ -21,8 +21,8 @@ class NET_EXPORT URLRequestAboutJob : public URLRequestJob {
   static URLRequest::ProtocolFactory Factory;
 
   // URLRequestJob:
-  virtual void Start();
-  virtual bool GetMimeType(std::string* mime_type) const;
+  virtual void Start() OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
 
  private:
   virtual ~URLRequestAboutJob();
diff --git a/net/url_request/url_request_data_job.h b/net/url_request/url_request_data_job.h
index 3880241..3a0fc27 100644
--- a/net/url_request/url_request_data_job.h
+++ b/net/url_request/url_request_data_job.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.
 
@@ -24,7 +24,7 @@ class URLRequestDataJob : public URLRequestSimpleJob {
   // URLRequestSimpleJob
   virtual bool GetData(std::string* mime_type,
                        std::string* charset,
-                       std::string* data) const;
+                       std::string* data) const OVERRIDE;
 
  private:
   virtual ~URLRequestDataJob();
diff --git a/net/url_request/url_request_error_job.h b/net/url_request/url_request_error_job.h
index fea3bf0..cdf28d9 100644
--- a/net/url_request/url_request_error_job.h
+++ b/net/url_request/url_request_error_job.h
@@ -19,7 +19,7 @@ class NET_EXPORT URLRequestErrorJob : public URLRequestJob {
  public:
   URLRequestErrorJob(URLRequest* request, int error);
 
-  virtual void Start();
+  virtual void Start() OVERRIDE;
 
  private:
   virtual ~URLRequestErrorJob();
diff --git a/net/url_request/url_request_file_dir_job.h b/net/url_request/url_request_file_dir_job.h
index ffc34bc..eb9437d 100644
--- a/net/url_request/url_request_file_dir_job.h
+++ b/net/url_request/url_request_file_dir_job.h
@@ -27,16 +27,18 @@ class URLRequestFileDirJob
   virtual void StartAsync();
 
   // Overridden from URLRequestJob:
-  virtual void Start();
-  virtual void Kill();
-  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
-  virtual bool GetMimeType(std::string* mime_type) const;
-  virtual bool GetCharset(std::string* charset);
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetCharset(std::string* charset) OVERRIDE;
 
   // Overridden from DirectoryLister::DirectoryListerDelegate:
   virtual void OnListFile(
-      const DirectoryLister::DirectoryListerData& data);
-  virtual void OnListDone(int error);
+      const DirectoryLister::DirectoryListerData& data) OVERRIDE;
+  virtual void OnListDone(int error) OVERRIDE;
 
  private:
   virtual ~URLRequestFileDirJob();
diff --git a/net/url_request/url_request_file_job.h b/net/url_request/url_request_file_job.h
index 6bc7d26..6f13b3a 100644
--- a/net/url_request/url_request_file_job.h
+++ b/net/url_request/url_request_file_job.h
@@ -35,13 +35,17 @@ class NET_EXPORT URLRequestFileJob : public URLRequestJob {
 #endif
 
   // URLRequestJob:
-  virtual void Start();
-  virtual void Kill();
-  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int* bytes_read);
-  virtual bool IsRedirectResponse(GURL* location, int* http_status_code);
-  virtual Filter* SetupFilter() const;
-  virtual bool GetMimeType(std::string* mime_type) const;
-  virtual void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int* bytes_read) OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
+  virtual Filter* SetupFilter() const OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual void SetExtraRequestHeaders(
+      const HttpRequestHeaders& headers) OVERRIDE;
 
  protected:
   virtual ~URLRequestFileJob();
diff --git a/net/url_request/url_request_ftp_job.h b/net/url_request/url_request_ftp_job.h
index 5cee887..bbec2b2 100644
--- a/net/url_request/url_request_ftp_job.h
+++ b/net/url_request/url_request_ftp_job.h
@@ -29,8 +29,8 @@ class URLRequestFtpJob : public URLRequestJob {
                                 const std::string& scheme);
 
   // Overridden from URLRequestJob:
-  virtual bool GetMimeType(std::string* mime_type) const;
-  virtual HostPortPair GetSocketAddress() const;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const OVERRIDE;
 
  private:
   virtual ~URLRequestFtpJob();
@@ -55,8 +55,10 @@ class URLRequestFtpJob : public URLRequestJob {
   virtual void CancelAuth() OVERRIDE;
 
   // TODO(ibrar):  Yet to give another look at this function.
-  virtual uint64 GetUploadProgress() const;
-  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
+  virtual uint64 GetUploadProgress() const OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
 
   FtpRequestInfo request_info_;
   scoped_ptr<FtpTransaction> transaction_;
diff --git a/net/url_request/url_request_http_job.h b/net/url_request/url_request_http_job.h
index d1594dd..e84c51d 100644
--- a/net/url_request/url_request_http_job.h
+++ b/net/url_request/url_request_http_job.h
@@ -149,7 +149,7 @@ class URLRequestHttpJob : public URLRequestJob {
   void RecordTimer();
   void ResetTimer();
 
-  virtual void UpdatePacketReadTimes();
+  virtual void UpdatePacketReadTimes() OVERRIDE;
   void RecordPacketStats(FilterContext::StatisticSelector statistic) const;
 
   void RecordCompressionHistograms();
diff --git a/net/url_request/url_request_job.h b/net/url_request/url_request_job.h
index 26d46d4..46bc54c 100644
--- a/net/url_request/url_request_job.h
+++ b/net/url_request/url_request_job.h
@@ -187,7 +187,7 @@ class NET_EXPORT URLRequestJob : public base::RefCounted<URLRequestJob>,
 
   // base::SystemMonitor::PowerObserver methods:
   // We invoke URLRequestJob::Kill on suspend (crbug.com/4606).
-  virtual void OnSuspend();
+  virtual void OnSuspend() OVERRIDE;
 
   // Called after a NetworkDelegate has been informed that the URLRequest
   // will be destroyed. This is used to track that no pending callbacks
diff --git a/net/url_request/url_request_netlog_params.h b/net/url_request/url_request_netlog_params.h
index 92b5404..9f0d574 100644
--- a/net/url_request/url_request_netlog_params.h
+++ b/net/url_request/url_request_netlog_params.h
@@ -33,7 +33,7 @@ class NET_EXPORT URLRequestStartEventParameters
     return load_flags_;
   }
 
-  virtual base::Value* ToValue() const;
+  virtual base::Value* ToValue() const OVERRIDE;
 
  private:
   const GURL url_;
diff --git a/net/url_request/url_request_redirect_job.h b/net/url_request/url_request_redirect_job.h
index a69f9d3..b63cf91 100644
--- a/net/url_request/url_request_redirect_job.h
+++ b/net/url_request/url_request_redirect_job.h
@@ -35,8 +35,9 @@ class NET_EXPORT URLRequestRedirectJob : public URLRequestJob {
     http_status_code_ = static_cast<int>(code);
   }
 
-  virtual void Start();
-  virtual bool IsRedirectResponse(GURL* location, int* http_status_code);
+  virtual void Start() OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
 
  private:
   virtual ~URLRequestRedirectJob();
diff --git a/net/url_request/url_request_simple_job.h b/net/url_request/url_request_simple_job.h
index dfe4ed2..9e22f28 100644
--- a/net/url_request/url_request_simple_job.h
+++ b/net/url_request/url_request_simple_job.h
@@ -20,10 +20,12 @@ class NET_EXPORT URLRequestSimpleJob : public URLRequestJob {
  public:
   explicit URLRequestSimpleJob(URLRequest* request);
 
-  virtual void Start();
-  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
-  virtual bool GetMimeType(std::string* mime_type) const;
-  virtual bool GetCharset(std::string* charset);
+  virtual void Start() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetCharset(std::string* charset) OVERRIDE;
 
  protected:
   virtual ~URLRequestSimpleJob();
diff --git a/net/url_request/url_request_test_job.h b/net/url_request/url_request_test_job.h
index 6162b69..439e80c 100644
--- a/net/url_request/url_request_test_job.h
+++ b/net/url_request/url_request_test_job.h
@@ -92,13 +92,16 @@ class NET_EXPORT_PRIVATE URLRequestTestJob : public URLRequestJob {
   static URLRequest::ProtocolFactory Factory;
 
   // Job functions
-  virtual void Start();
-  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
-  virtual void Kill();
-  virtual bool GetMimeType(std::string* mime_type) const;
-  virtual void GetResponseInfo(HttpResponseInfo* info);
-  virtual int GetResponseCode() const;
-  virtual bool IsRedirectResponse(GURL* location, int* http_status_code);
+  virtual void Start() OVERRIDE;
+  virtual bool ReadRawData(IOBuffer* buf,
+                           int buf_size,
+                           int *bytes_read) OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
+  virtual bool IsRedirectResponse(GURL* location,
+                                  int* http_status_code) OVERRIDE;
 
  protected:
   // This is what operation we are going to do next when this job is handled.
diff --git a/net/url_request/url_request_throttler_entry.h b/net/url_request/url_request_throttler_entry.h
index f4ad2c9..8a2589b 100644
--- a/net/url_request/url_request_throttler_entry.h
+++ b/net/url_request/url_request_throttler_entry.h
@@ -97,14 +97,14 @@ class NET_EXPORT URLRequestThrottlerEntry
   void DetachManager();
 
   // Implementation of URLRequestThrottlerEntryInterface.
-  virtual bool ShouldRejectRequest(int load_flags) const;
+  virtual bool ShouldRejectRequest(int load_flags) const OVERRIDE;
   virtual int64 ReserveSendingTimeForNextRequest(
-      const base::TimeTicks& earliest_time);
-  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const;
+      const base::TimeTicks& earliest_time) OVERRIDE;
+  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const OVERRIDE;
   virtual void UpdateWithResponse(
       const std::string& host,
-      const URLRequestThrottlerHeaderInterface* response);
-  virtual void ReceivedContentWasMalformed(int response_code);
+      const URLRequestThrottlerHeaderInterface* response) OVERRIDE;
+  virtual void ReceivedContentWasMalformed(int response_code) OVERRIDE;
 
  protected:
   virtual ~URLRequestThrottlerEntry();
diff --git a/net/url_request/url_request_throttler_header_adapter.h b/net/url_request/url_request_throttler_header_adapter.h
index 6226bdf..d80cede 100644
--- a/net/url_request/url_request_throttler_header_adapter.h
+++ b/net/url_request/url_request_throttler_header_adapter.h
@@ -8,6 +8,7 @@
 
 #include <string>
 
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "net/url_request/url_request_throttler_header_interface.h"
 
@@ -23,8 +24,8 @@ class URLRequestThrottlerHeaderAdapter
   virtual ~URLRequestThrottlerHeaderAdapter();
 
   // Implementation of URLRequestThrottlerHeaderInterface
-  virtual std::string GetNormalizedValue(const std::string& key) const;
-  virtual int GetResponseCode() const;
+  virtual std::string GetNormalizedValue(const std::string& key) const OVERRIDE;
+  virtual int GetResponseCode() const OVERRIDE;
 
  private:
   const scoped_refptr<HttpResponseHeaders> response_header_;
diff --git a/net/websockets/websocket_job.h b/net/websockets/websocket_job.h
index f3c0ab1..4df3315 100644
--- a/net/websockets/websocket_job.h
+++ b/net/websockets/websocket_job.h
@@ -53,31 +53,34 @@ class NET_EXPORT WebSocketJob
   static void set_websocket_over_spdy_enabled(bool enabled);
 
   State state() const { return state_; }
-  virtual void Connect();
-  virtual bool SendData(const char* data, int len);
-  virtual void Close();
-  virtual void RestartWithAuth(const AuthCredentials& credentials);
-  virtual void DetachDelegate();
+  virtual void Connect() OVERRIDE;
+  virtual bool SendData(const char* data, int len) OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual void RestartWithAuth(const AuthCredentials& credentials) OVERRIDE;
+  virtual void DetachDelegate() OVERRIDE;
 
   // SocketStream::Delegate methods.
   virtual int OnStartOpenConnection(
-      SocketStream* socket, OldCompletionCallback* callback);
-  virtual void OnConnected(SocketStream* socket, int max_pending_send_allowed);
-  virtual void OnSentData(SocketStream* socket, int amount_sent);
-  virtual void OnReceivedData(SocketStream* socket, const char* data, int len);
-  virtual void OnClose(SocketStream* socket);
+      SocketStream* socket, OldCompletionCallback* callback) OVERRIDE;
+  virtual void OnConnected(SocketStream* socket,
+                           int max_pending_send_allowed) OVERRIDE;
+  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE;
+  virtual void OnReceivedData(SocketStream* socket,
+                              const char* data,
+                              int len) OVERRIDE;
+  virtual void OnClose(SocketStream* socket) OVERRIDE;
   virtual void OnAuthRequired(
-      SocketStream* socket, AuthChallengeInfo* auth_info);
-  virtual void OnError(const SocketStream* socket, int error);
+      SocketStream* socket, AuthChallengeInfo* auth_info) OVERRIDE;
+  virtual void OnError(const SocketStream* socket, int error) OVERRIDE;
 
   // SpdyWebSocketStream::Delegate methods.
-  virtual void OnCreatedSpdyStream(int status);
-  virtual void OnSentSpdyHeaders(int status);
+  virtual void OnCreatedSpdyStream(int status) OVERRIDE;
+  virtual void OnSentSpdyHeaders(int status) OVERRIDE;
   virtual int OnReceivedSpdyResponseHeader(
-      const spdy::SpdyHeaderBlock& headers, int status);
-  virtual void OnSentSpdyData(int amount_sent);
-  virtual void OnReceivedSpdyData(const char* data, int length);
-  virtual void OnCloseSpdyStream();
+      const spdy::SpdyHeaderBlock& headers, int status) OVERRIDE;
+  virtual void OnSentSpdyData(int amount_sent) OVERRIDE;
+  virtual void OnReceivedSpdyData(const char* data, int length) OVERRIDE;
+  virtual void OnCloseSpdyStream() OVERRIDE;
 
  private:
   friend class WebSocketThrottle;
diff --git a/net/websockets/websocket_net_log_params.h b/net/websockets/websocket_net_log_params.h
index 7b90305..ac53856 100644
--- a/net/websockets/websocket_net_log_params.h
+++ b/net/websockets/websocket_net_log_params.h
@@ -24,7 +24,7 @@ class NET_EXPORT_PRIVATE NetLogWebSocketHandshakeParameter
  public:
   explicit NetLogWebSocketHandshakeParameter(const std::string& headers);
 
-  virtual Value* ToValue() const;
+  virtual Value* ToValue() const OVERRIDE;
 
  private:
   virtual ~NetLogWebSocketHandshakeParameter();