Linux/ChromeOS Chromium style checker cleanup, net/ edition.

Automated clean up of style checker errors that were missed due to the plugin
not being executed on implementation files.

BUG=115047

Review URL: https://chromiumcodereview.appspot.com/12223022

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

49 files changed, 387 insertions, 348 deletions

diff --git a/net/base/directory_lister_unittest.cc b/net/base/directory_lister_unittest.cc
index 7a34e65..8759946 100644
--- a/net/base/directory_lister_unittest.cc
+++ b/net/base/directory_lister_unittest.cc
@@ -24,14 +24,15 @@ class ListerDelegate : public DirectoryLister::DirectoryListerDelegate {
         quit_loop_after_each_file_(quit_loop_after_each_file) {
   }
 
-  void OnListFile(const DirectoryLister::DirectoryListerData& data) {
+  virtual void OnListFile(
+      const DirectoryLister::DirectoryListerData& data) OVERRIDE {
     file_list_.push_back(data.info);
     paths_.push_back(data.path);
     if (quit_loop_after_each_file_)
       MessageLoop::current()->Quit();
   }
 
-  void OnListDone(int error) {
+  virtual void OnListDone(int error) OVERRIDE {
     error_ = error;
     MessageLoop::current()->Quit();
     if (recursive_)
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index bc6b870..d0c8fcb 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -163,7 +163,7 @@ class MockHostResolverProc : public HostResolverProc {
   }
 
  protected:
-  ~MockHostResolverProc() {}
+  virtual ~MockHostResolverProc() {}
 
  private:
   mutable base::Lock lock_;
diff --git a/net/base/ssl_config_service_unittest.cc b/net/base/ssl_config_service_unittest.cc
index 1d12879..a0d85db 100644
--- a/net/base/ssl_config_service_unittest.cc
+++ b/net/base/ssl_config_service_unittest.cc
@@ -19,7 +19,7 @@ class MockSSLConfigService : public SSLConfigService {
   explicit MockSSLConfigService(const SSLConfig& config) : config_(config) {}
 
   // SSLConfigService implementation
-  virtual void GetSSLConfig(SSLConfig* config) {
+  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
     *config = config_;
   }
 
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index 439f4c8..8be6923 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -1810,24 +1810,25 @@ class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
-  void Load(const LoadedCallback& loaded_callback) {
+  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE {
     std::vector<CanonicalCookie*> out_cookies;
     MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&net::LoadedCallbackTask::Run,
                  new net::LoadedCallbackTask(loaded_callback, out_cookies)));
   }
 
-  void LoadCookiesForKey(const std::string& key,
-      const LoadedCallback& loaded_callback) {
+  virtual void LoadCookiesForKey(
+      const std::string& key,
+      const LoadedCallback& loaded_callback) OVERRIDE {
     Load(loaded_callback);
   }
 
-  void AddCookie(const CanonicalCookie&) {}
-  void UpdateCookieAccessTime(const CanonicalCookie&) {}
-  void DeleteCookie(const CanonicalCookie&) {}
-  void SetForceKeepSessionState() {}
+  virtual void AddCookie(const CanonicalCookie&) OVERRIDE {}
+  virtual void UpdateCookieAccessTime(const CanonicalCookie&) OVERRIDE {}
+  virtual void DeleteCookie(const CanonicalCookie&) OVERRIDE {}
+  virtual void SetForceKeepSessionState() OVERRIDE {}
 
-  void Flush(const base::Closure& callback) {
+  virtual void Flush(const base::Closure& callback) OVERRIDE {
     ++flush_count_;
     if (!callback.is_null())
       callback.Run();
diff --git a/net/disk_cache/cache_util_unittest.cc b/net/disk_cache/cache_util_unittest.cc
index 919df7b..07f0ac0 100644
--- a/net/disk_cache/cache_util_unittest.cc
+++ b/net/disk_cache/cache_util_unittest.cc
@@ -12,7 +12,7 @@ namespace disk_cache {
 
 class CacheUtilTest : public PlatformTest {
  public:
-  void SetUp() {
+  virtual void SetUp() {
     PlatformTest::SetUp();
     ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
     cache_dir_ = tmp_dir_.path().Append(FILE_PATH_LITERAL("Cache"));
diff --git a/net/disk_cache/mapped_file_unittest.cc b/net/disk_cache/mapped_file_unittest.cc
index fa566eb..297de33 100644
--- a/net/disk_cache/mapped_file_unittest.cc
+++ b/net/disk_cache/mapped_file_unittest.cc
@@ -22,7 +22,7 @@ class FileCallbackTest: public disk_cache::FileIOCallback {
   }
   virtual ~FileCallbackTest() {}
 
-  virtual void OnFileIOComplete(int bytes_copied);
+  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
 
  private:
   int id_;
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index 9184023..c3c4c8f 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -440,7 +440,7 @@ class DnsTransactionTest : public testing::Test {
     }
   }
 
-  void SetUp() OVERRIDE {
+  virtual void SetUp() OVERRIDE {
     // By default set one server,
     ConfigureNumServers(1);
     // and no retransmissions,
@@ -450,7 +450,7 @@ class DnsTransactionTest : public testing::Test {
     ConfigureFactory();
   }
 
-  void TearDown() OVERRIDE {
+  virtual void TearDown() OVERRIDE {
     // Check that all socket data was at least written to.
     for (size_t i = 0; i < socket_data_.size(); ++i) {
       EXPECT_TRUE(socket_data_[i]->was_written()) << i;
diff --git a/net/http/http_auth_cache_unittest.cc b/net/http/http_auth_cache_unittest.cc
index d782f5e..286d44a 100644
--- a/net/http/http_auth_cache_unittest.cc
+++ b/net/http/http_auth_cache_unittest.cc
@@ -31,26 +31,26 @@ class MockAuthHandler : public HttpAuthHandler {
   }
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuth::ChallengeTokenizer* challenge) {
+      HttpAuth::ChallengeTokenizer* challenge) OVERRIDE {
     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
   }
 
  protected:
-  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) {
+  virtual bool Init(HttpAuth::ChallengeTokenizer* challenge) OVERRIDE {
     return false;  // Unused.
   }
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials*,
                                     const HttpRequestInfo*,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) {
+                                    std::string* auth_token) OVERRIDE {
     *auth_token = "mock-credentials";
     return OK;
   }
 
 
  private:
-  ~MockAuthHandler() {}
+  virtual ~MockAuthHandler() {}
 };
 
 const char* kRealm1 = "Realm1";
diff --git a/net/http/http_auth_handler_factory_unittest.cc b/net/http/http_auth_handler_factory_unittest.cc
index 906f47d..cc5c6d4 100644
--- a/net/http/http_auth_handler_factory_unittest.cc
+++ b/net/http/http_auth_handler_factory_unittest.cc
@@ -27,7 +27,7 @@ class MockHttpAuthHandlerFactory : public HttpAuthHandlerFactory {
                                 CreateReason reason,
                                 int nonce_count,
                                 const BoundNetLog& net_log,
-                                scoped_ptr<HttpAuthHandler>* handler) {
+                                scoped_ptr<HttpAuthHandler>* handler) OVERRIDE {
     handler->reset();
     return return_code_;
   }
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index c76d205d..3172a92 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -8496,7 +8496,7 @@ class CapturingProxyResolver : public ProxyResolver {
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) {
+                             const BoundNetLog& net_log) OVERRIDE {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
     results->UseProxyServer(proxy_server);
@@ -8504,7 +8504,7 @@ class CapturingProxyResolver : public ProxyResolver {
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) {
+  virtual void CancelRequest(RequestHandle request) OVERRIDE {
     NOTREACHED();
   }
 
@@ -8513,12 +8513,12 @@ class CapturingProxyResolver : public ProxyResolver {
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() {
+  virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
-                           const CompletionCallback& /*callback*/) {
+                           const CompletionCallback& /*callback*/) OVERRIDE {
     return OK;
   }
 
@@ -9366,7 +9366,7 @@ class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
       : fail_all_(fail_all) {
   }
 
-  virtual MockRead GetNextRead() {
+  virtual MockRead GetNextRead() OVERRIDE {
     if (fail_all_)
       return MockRead(SYNCHRONOUS, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
 
@@ -9374,11 +9374,11 @@ class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
                     "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nok.\r\n");
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) {
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     return MockWriteResult(SYNCHRONOUS /* async */, data.size());
   }
 
-  void Reset() {
+  virtual void Reset() OVERRIDE {
   }
 
  private:
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index e0787d6..7d9b2df 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -8476,7 +8476,7 @@ class CapturingProxyResolver : public ProxyResolver {
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) {
+                             const BoundNetLog& net_log) OVERRIDE {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
     results->UseProxyServer(proxy_server);
@@ -8484,7 +8484,7 @@ class CapturingProxyResolver : public ProxyResolver {
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) {
+  virtual void CancelRequest(RequestHandle request) OVERRIDE {
     NOTREACHED();
   }
 
@@ -8493,12 +8493,12 @@ class CapturingProxyResolver : public ProxyResolver {
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() {
+  virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
-                           const CompletionCallback& /*callback*/) {
+                           const CompletionCallback& /*callback*/) OVERRIDE {
     return OK;
   }
 
@@ -9346,7 +9346,7 @@ class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
       : fail_all_(fail_all) {
   }
 
-  virtual MockRead GetNextRead() {
+  virtual MockRead GetNextRead() OVERRIDE {
     if (fail_all_)
       return MockRead(SYNCHRONOUS, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
 
@@ -9354,11 +9354,11 @@ class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
                     "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nok.\r\n");
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) {
+  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     return MockWriteResult(SYNCHRONOUS /* async */, data.size());
   }
 
-  void Reset() {
+  virtual void Reset() OVERRIDE {
   }
 
  private:
diff --git a/net/http/http_response_body_drainer_unittest.cc b/net/http/http_response_body_drainer_unittest.cc
index 6294a3e..d6bde8a 100644
--- a/net/http/http_response_body_drainer_unittest.cc
+++ b/net/http/http_response_body_drainer_unittest.cc
@@ -216,7 +216,7 @@ class HttpResponseBodyDrainerTest : public testing::Test {
         mock_stream_(new MockHttpStream(&result_waiter_)),
         drainer_(new HttpResponseBodyDrainer(mock_stream_)) {}
 
-  ~HttpResponseBodyDrainerTest() {}
+  virtual ~HttpResponseBodyDrainerTest() {}
 
   HttpNetworkSession* CreateNetworkSession() const {
     HttpNetworkSession::Params params;
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index 6a74ca9..2eb42be 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -223,7 +223,7 @@ class BlockableProxyResolverFactory : public ProxyResolverFactory {
  public:
   BlockableProxyResolverFactory() : ProxyResolverFactory(true) {}
 
-  ~BlockableProxyResolverFactory() {
+  virtual ~BlockableProxyResolverFactory() {
     STLDeleteElements(&resolvers_);
   }
 
diff --git a/net/proxy/proxy_resolver_v8_tracing.cc b/net/proxy/proxy_resolver_v8_tracing.cc
index aedd759..67d29eb 100644
--- a/net/proxy/proxy_resolver_v8_tracing.cc
+++ b/net/proxy/proxy_resolver_v8_tracing.cc
@@ -125,7 +125,7 @@ class ProxyResolverV8Tracing::Job
     string16 message;
   };
 
-  ~Job();
+  virtual ~Job();
 
   void CheckIsOnWorkerThread() const;
   void CheckIsOnOriginThread() const;
diff --git a/net/proxy/proxy_script_decider_unittest.cc b/net/proxy/proxy_script_decider_unittest.cc
index 62075c4..82f01d8 100644
--- a/net/proxy/proxy_script_decider_unittest.cc
+++ b/net/proxy/proxy_script_decider_unittest.cc
@@ -98,7 +98,7 @@ class RuleBasedProxyScriptFetcher : public ProxyScriptFetcher {
   // ProxyScriptFetcher implementation.
   virtual int Fetch(const GURL& url,
                     string16* text,
-                    const CompletionCallback& callback) {
+                    const CompletionCallback& callback) OVERRIDE {
     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
     int rv = rule.fetch_error;
     EXPECT_NE(ERR_UNEXPECTED, rv);
@@ -107,9 +107,9 @@ class RuleBasedProxyScriptFetcher : public ProxyScriptFetcher {
     return rv;
   }
 
-  virtual void Cancel() {}
+  virtual void Cancel() OVERRIDE {}
 
-  virtual URLRequestContext* GetRequestContext() const { return NULL; }
+  virtual URLRequestContext* GetRequestContext() const OVERRIDE { return NULL; }
 
  private:
   const Rules* rules_;
@@ -457,15 +457,16 @@ class SynchronousSuccessDhcpFetcher : public DhcpProxyScriptFetcher {
       : gurl_("http://dhcppac/"), expected_text_(expected_text) {
   }
 
-  int Fetch(string16* utf16_text, const CompletionCallback& callback) OVERRIDE {
+  virtual int Fetch(string16* utf16_text,
+                    const CompletionCallback& callback) OVERRIDE {
     *utf16_text = expected_text_;
     return OK;
   }
 
-  void Cancel() OVERRIDE {
+  virtual void Cancel() OVERRIDE {
   }
 
-  const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const OVERRIDE {
     return gurl_;
   }
 
@@ -536,9 +537,10 @@ class AsyncFailDhcpFetcher
       public base::SupportsWeakPtr<AsyncFailDhcpFetcher> {
  public:
   AsyncFailDhcpFetcher() {}
-  ~AsyncFailDhcpFetcher() {}
+  virtual ~AsyncFailDhcpFetcher() {}
 
-  int Fetch(string16* utf16_text, const CompletionCallback& callback) OVERRIDE {
+  virtual int Fetch(string16* utf16_text,
+                    const CompletionCallback& callback) OVERRIDE {
     callback_ = callback;
     MessageLoop::current()->PostTask(
         FROM_HERE,
@@ -546,11 +548,11 @@ class AsyncFailDhcpFetcher
     return ERR_IO_PENDING;
   }
 
-  void Cancel() OVERRIDE {
+  virtual void Cancel() OVERRIDE {
     callback_.Reset();
   }
 
-  const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const OVERRIDE {
     return dummy_gurl_;
   }
 
diff --git a/net/quic/congestion_control/cubic_test.cc b/net/quic/congestion_control/cubic_test.cc
index f40a591..84f2a7b 100644
--- a/net/quic/congestion_control/cubic_test.cc
+++ b/net/quic/congestion_control/cubic_test.cc
@@ -26,7 +26,7 @@ class CubicTest : public ::testing::Test {
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
         hundred_ms_(QuicTime::Delta::FromMilliseconds(100)) {
   }
-  void SetUp() {
+  virtual void SetUp() {
     cubic_.reset(new CubicPeer(&clock_));
   }
   const QuicTime::Delta one_ms_;
diff --git a/net/quic/congestion_control/hybrid_slow_start_test.cc b/net/quic/congestion_control/hybrid_slow_start_test.cc
index c913694..0a9f91f 100644
--- a/net/quic/congestion_control/hybrid_slow_start_test.cc
+++ b/net/quic/congestion_control/hybrid_slow_start_test.cc
@@ -17,7 +17,7 @@ class HybridSlowStartTest : public ::testing::Test {
      : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
        rtt_(QuicTime::Delta::FromMilliseconds(60)) {
   }
-  void SetUp() {
+  virtual void SetUp() {
     slowStart_.reset(new HybridSlowStart(&clock_));
   }
   const QuicTime::Delta one_ms_;
diff --git a/net/quic/congestion_control/leaky_bucket_test.cc b/net/quic/congestion_control/leaky_bucket_test.cc
index a510200..89ab5db 100644
--- a/net/quic/congestion_control/leaky_bucket_test.cc
+++ b/net/quic/congestion_control/leaky_bucket_test.cc
@@ -13,7 +13,7 @@ namespace test {
 
 class LeakyBucketTest : public ::testing::Test {
  protected:
-  void SetUp() {
+  virtual void SetUp() {
     leaky_bucket_.reset(new LeakyBucket(&clock_, QuicBandwidth::Zero()));
   }
   MockClock clock_;
diff --git a/net/quic/congestion_control/tcp_receiver_test.cc b/net/quic/congestion_control/tcp_receiver_test.cc
index 5bb12f4..305ff75 100644
--- a/net/quic/congestion_control/tcp_receiver_test.cc
+++ b/net/quic/congestion_control/tcp_receiver_test.cc
@@ -13,7 +13,7 @@ namespace test {
 
 class QuicTcpReceiverTest : public ::testing::Test {
  protected:
-  void SetUp() {
+  virtual void SetUp() {
     receiver_.reset(new TcpReceiver());
   }
   scoped_ptr<TcpReceiver> receiver_;
diff --git a/net/quic/crypto/crypto_framer_test.cc b/net/quic/crypto/crypto_framer_test.cc
index 87c5c2a..93d7d58 100644
--- a/net/quic/crypto/crypto_framer_test.cc
+++ b/net/quic/crypto/crypto_framer_test.cc
@@ -34,12 +34,13 @@ class TestCryptoVisitor : public ::net::CryptoFramerVisitorInterface {
       : error_count_(0) {
   }
 
-  virtual void OnError(CryptoFramer* framer) {
+  virtual void OnError(CryptoFramer* framer) OVERRIDE {
     DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
     ++error_count_;
   }
 
-  virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/crypto/quic_random.cc b/net/quic/crypto/quic_random.cc
index 579ebec..9a67918 100644
--- a/net/quic/crypto/quic_random.cc
+++ b/net/quic/crypto/quic_random.cc
@@ -17,9 +17,10 @@ class DefaultRandom : public QuicRandom {
   static DefaultRandom* GetInstance();
 
   // QuicRandom implementation
-  virtual void RandBytes(void* data, size_t len);
-  virtual uint64 RandUint64();
-  virtual void Reseed(const void* additional_entropy, size_t entropy_len);
+  virtual void RandBytes(void* data, size_t len) OVERRIDE;
+  virtual uint64 RandUint64() OVERRIDE;
+  virtual void Reseed(const void* additional_entropy,
+                      size_t entropy_len) OVERRIDE;
 
  private:
   DefaultRandom();
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 1dbde23..51a9784 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -71,18 +71,18 @@ class TestConnectionHelper : public QuicConnectionHelperInterface {
   }
 
   // QuicConnectionHelperInterface
-  virtual void SetConnection(QuicConnection* connection) {}
+  virtual void SetConnection(QuicConnection* connection) OVERRIDE {}
 
-  virtual const QuicClock* GetClock() const {
+  virtual const QuicClock* GetClock() const OVERRIDE {
     return clock_;
   }
 
-  virtual QuicRandom* GetRandomGenerator() {
+  virtual QuicRandom* GetRandomGenerator() OVERRIDE {
     return random_generator_;
   }
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
-                                int* error) {
+                                int* error) OVERRIDE {
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     FramerVisitorCapturingAcks visitor;
@@ -103,28 +103,28 @@ class TestConnectionHelper : public QuicConnectionHelperInterface {
     return packet.length();
   }
 
-  virtual void SetRetransmissionAlarm(QuicTime::Delta delay) {
+  virtual void SetRetransmissionAlarm(QuicTime::Delta delay) OVERRIDE {
     retransmission_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual void SetSendAlarm(QuicTime::Delta delay) {
+  virtual void SetSendAlarm(QuicTime::Delta delay) OVERRIDE {
     send_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual void SetTimeoutAlarm(QuicTime::Delta delay) {
+  virtual void SetTimeoutAlarm(QuicTime::Delta delay) OVERRIDE {
     timeout_alarm_ = clock_->Now().Add(delay);
   }
 
-  virtual bool IsSendAlarmSet() {
+  virtual bool IsSendAlarmSet() OVERRIDE {
     return send_alarm_ > clock_->Now();
   }
 
-  virtual void UnregisterSendAlarmIfRegistered() {
+  virtual void UnregisterSendAlarmIfRegistered() OVERRIDE {
     send_alarm_ = QuicTime::Zero();
   }
 
-  virtual void SetAckAlarm(QuicTime::Delta delay) {}
-  virtual void ClearAckAlarm() {}
+  virtual void SetAckAlarm(QuicTime::Delta delay) OVERRIDE {}
+  virtual void ClearAckAlarm() OVERRIDE {}
 
   QuicTime retransmission_alarm() const {
     return retransmission_alarm_;
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index adbf139..be53dc6 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -20,7 +20,7 @@ class TestQuicVisitor : public NoOpFramerVisitor {
   TestQuicVisitor() {}
 
   // NoOpFramerVisitor
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) {
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_ = frame;
   }
 
@@ -38,12 +38,13 @@ class TestCryptoVisitor : public CryptoFramerVisitorInterface {
       : error_count_(0) {
   }
 
-  virtual void OnError(CryptoFramer* framer) {
+  virtual void OnError(CryptoFramer* framer) OVERRIDE {
     DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
     ++error_count_;
   }
 
-  virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
@@ -61,7 +62,7 @@ class TestMockHelper : public MockHelper  {
   virtual ~TestMockHelper() {}
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
-                                int* error) {
+                                int* error) OVERRIDE {
     packet_count_++;
 
     // The first packet should be ClientHello.
@@ -158,8 +159,10 @@ class TestMockSession : public MockSession {
   }
   virtual ~TestMockSession() {}
 
-  virtual QuicConsumedData WriteData(QuicStreamId id, StringPiece data,
-                                     QuicStreamOffset offset, bool fin) {
+  virtual QuicConsumedData WriteData(QuicStreamId id,
+                                     StringPiece data,
+                                     QuicStreamOffset offset,
+                                     bool fin) OVERRIDE {
     return QuicSession::WriteData(id, data, offset, fin);
   }
 };
diff --git a/net/quic/quic_crypto_stream_test.cc b/net/quic/quic_crypto_stream_test.cc
index ef1c61c..10f1657 100644
--- a/net/quic/quic_crypto_stream_test.cc
+++ b/net/quic/quic_crypto_stream_test.cc
@@ -25,7 +25,8 @@ class MockQuicCryptoStream : public QuicCryptoStream {
       : QuicCryptoStream(session) {
   }
 
-  void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 2b5cb38..d64df49 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -50,15 +50,15 @@ class TestEncrypter : public QuicEncrypter {
  public:
   virtual ~TestEncrypter() {}
   virtual QuicData* Encrypt(StringPiece associated_data,
-                            StringPiece plaintext) {
+                            StringPiece plaintext) OVERRIDE {
     associated_data_ = associated_data.as_string();
     plaintext_ = plaintext.as_string();
     return new QuicData(plaintext.data(), plaintext.length());
   }
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) {
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) OVERRIDE {
     return ciphertext_size;
   }
-  virtual size_t GetCiphertextSize(size_t plaintext_size) {
+  virtual size_t GetCiphertextSize(size_t plaintext_size) OVERRIDE {
     return plaintext_size;
   }
   string associated_data_;
@@ -69,7 +69,7 @@ class TestDecrypter : public QuicDecrypter {
  public:
   virtual ~TestDecrypter() {}
   virtual QuicData* Decrypt(StringPiece associated_data,
-                            StringPiece ciphertext) {
+                            StringPiece ciphertext) OVERRIDE {
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     return new QuicData(ciphertext.data(), ciphertext.length());
@@ -90,71 +90,72 @@ class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
         accept_packet_(true) {
   }
 
-  ~TestQuicVisitor() {
+  virtual ~TestQuicVisitor() {
     STLDeleteElements(&stream_frames_);
     STLDeleteElements(&ack_frames_);
     STLDeleteElements(&congestion_feedback_frames_);
     STLDeleteElements(&fec_data_);
   }
 
-  virtual void OnError(QuicFramer* f) {
+  virtual void OnError(QuicFramer* f) OVERRIDE {
     DLOG(INFO) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
                << " (" << f->error() << ")";
     error_count_++;
   }
 
-  virtual void OnPacket() {}
+  virtual void OnPacket() OVERRIDE {}
 
-  virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {
+  virtual void OnPublicResetPacket(
+      const QuicPublicResetPacket& packet) OVERRIDE {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
-  virtual void OnRevivedPacket() {
+  virtual void OnRevivedPacket() OVERRIDE {
     revived_packets_++;
   }
 
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) {
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) {
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_count_++;
     stream_frames_.push_back(new QuicStreamFrame(frame));
   }
 
-  virtual void OnFecProtectedPayload(StringPiece payload) {
+  virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {
     fec_protected_payload_ = payload.as_string();
   }
 
-  virtual void OnAckFrame(const QuicAckFrame& frame) {
+  virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
     frame_count_++;
     ack_frames_.push_back(new QuicAckFrame(frame));
   }
 
   virtual void OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) {
+      const QuicCongestionFeedbackFrame& frame) OVERRIDE {
     frame_count_++;
     congestion_feedback_frames_.push_back(
         new QuicCongestionFeedbackFrame(frame));
   }
 
-  virtual void OnFecData(const QuicFecData& fec) {
+  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
     fec_count_++;
     fec_data_.push_back(new QuicFecData(fec));
   }
 
-  virtual void OnPacketComplete() {
+  virtual void OnPacketComplete() OVERRIDE {
     complete_packets_++;
   }
 
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
     rst_stream_frame_ = frame;
   }
 
   virtual void OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) {
+      const QuicConnectionCloseFrame& frame) OVERRIDE {
     connection_close_frame_ = frame;
   }
 
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 5cdf5cd..641a306 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -86,7 +86,7 @@ class AutoClosingStream : public QuicHttpStream {
       : QuicHttpStream(stream, use_spdy) {
   }
 
-  virtual int OnDataReceived(const char* data, int length) {
+  virtual int OnDataReceived(const char* data, int length) OVERRIDE {
     Close(false);
     return OK;
   }
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index 1c41ffd..ef0efbe3 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -28,29 +28,29 @@ class VisitorShim : public QuicConnectionVisitorInterface {
   virtual bool OnPacket(const IPEndPoint& self_address,
                         const IPEndPoint& peer_address,
                         const QuicPacketHeader& header,
-                        const vector<QuicStreamFrame>& frame) {
+                        const vector<QuicStreamFrame>& frame) OVERRIDE {
     bool accepted = session_->OnPacket(self_address, peer_address, header,
                                        frame);
     session_->PostProcessAfterData();
     return accepted;
   }
-  virtual void OnRstStream(const QuicRstStreamFrame& frame) {
+  virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnAck(AckedPackets acked_packets) {
+  virtual void OnAck(AckedPackets acked_packets) OVERRIDE {
     session_->OnAck(acked_packets);
     session_->PostProcessAfterData();
   }
 
-  virtual bool OnCanWrite() {
+  virtual bool OnCanWrite() OVERRIDE {
     bool rc = session_->OnCanWrite();
     session_->PostProcessAfterData();
     return rc;
   }
 
-  virtual void ConnectionClose(QuicErrorCode error, bool from_peer) {
+  virtual void ConnectionClose(QuicErrorCode error, bool from_peer) OVERRIDE {
     session_->ConnectionClose(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
index 0f2d0ac..daf904e 100644
--- a/net/quic/quic_session_test.cc
+++ b/net/quic/quic_session_test.cc
@@ -27,7 +27,8 @@ class TestCryptoStream : public QuicCryptoStream {
       : QuicCryptoStream(session) {
   }
 
-  void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE {
     SetHandshakeComplete(QUIC_NO_ERROR);
   }
 };
@@ -52,17 +53,17 @@ class TestSession : public QuicSession {
         crypto_stream_(this) {
   }
 
-  virtual QuicCryptoStream* GetCryptoStream() {
+  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
-  virtual TestStream* CreateOutgoingReliableStream() {
+  virtual TestStream* CreateOutgoingReliableStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
-  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) {
+  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) OVERRIDE {
     return new TestStream(id, this);
   }
 
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 86323ac..014f6de 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -28,7 +28,7 @@ class QuicReliableTestStream : public ReliableQuicStream {
   QuicReliableTestStream(QuicStreamId id, QuicSession* session)
       : ReliableQuicStream(id, session) {
   }
-  virtual uint32 ProcessData(const char* data, uint32 data_len) {
+  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
     return 0;
   }
   using ReliableQuicStream::WriteData;
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index ca19b6f..992524e 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -137,8 +137,8 @@ class MockClientSocket : public StreamSocket {
     was_used_to_convey_data_ = true;
     return len;
   }
-  virtual bool SetReceiveBufferSize(int32 size) { return true; }
-  virtual bool SetSendBufferSize(int32 size) { return true; }
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; }
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; }
 
   // StreamSocket implementation.
   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
@@ -146,41 +146,41 @@ class MockClientSocket : public StreamSocket {
     return OK;
   }
 
-  virtual void Disconnect() { connected_ = false; }
-  virtual bool IsConnected() const { return connected_; }
-  virtual bool IsConnectedAndIdle() const { return connected_; }
+  virtual void Disconnect() OVERRIDE { connected_ = false; }
+  virtual bool IsConnected() const OVERRIDE { return connected_; }
+  virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; }
 
-  virtual int GetPeerAddress(IPEndPoint* /* address */) const {
+  virtual int GetPeerAddress(IPEndPoint* /* address */) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
 
-  virtual int GetLocalAddress(IPEndPoint* /* address */) const {
+  virtual int GetLocalAddress(IPEndPoint* /* address */) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
 
-  virtual const BoundNetLog& NetLog() const {
+  virtual const BoundNetLog& NetLog() const OVERRIDE {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() {}
-  virtual void SetOmniboxSpeculation() {}
-  virtual bool WasEverUsed() const {
+  virtual void SetSubresourceSpeculation() OVERRIDE {}
+  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual bool WasEverUsed() const OVERRIDE {
     return was_used_to_convey_data_ || num_bytes_read_ > 0;
   }
-  virtual bool UsingTCPFastOpen() const { return false; }
-  virtual int64 NumBytesRead() const { return num_bytes_read_; }
-  virtual base::TimeDelta GetConnectTimeMicros() const {
+  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
+  virtual int64 NumBytesRead() const OVERRIDE { return num_bytes_read_; }
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE {
     static const base::TimeDelta kDummyConnectTimeMicros =
         base::TimeDelta::FromMicroseconds(10);
     return kDummyConnectTimeMicros;  // Dummy value.
   }
-  virtual bool WasNpnNegotiated() const {
+  virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const {
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
@@ -203,7 +203,7 @@ 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 {
     NOTREACHED();
     return NULL;
   }
@@ -211,7 +211,7 @@ class MockClientSocketFactory : public ClientSocketFactory {
   virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
-      const NetLog::Source& /*source*/) {
+      const NetLog::Source& /*source*/) OVERRIDE {
     allocation_count_++;
     return NULL;
   }
@@ -220,12 +220,12 @@ class MockClientSocketFactory : public ClientSocketFactory {
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) {
+      const SSLClientSocketContext& context) OVERRIDE {
     NOTIMPLEMENTED();
     return NULL;
   }
 
-  virtual void ClearSSLSessionCache() {
+  virtual void ClearSSLSessionCache() OVERRIDE {
     NOTIMPLEMENTED();
   }
 
@@ -277,9 +277,9 @@ class TestConnectJob : public ConnectJob {
     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
   }
 
-  virtual LoadState GetLoadState() const { return load_state_; }
+  virtual LoadState GetLoadState() const OVERRIDE { return load_state_; }
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE {
     if (store_additional_error_state_) {
       // Set all of the additional error state fields in some way.
       handle->set_is_ssl_error(true);
@@ -292,7 +292,7 @@ class TestConnectJob : public ConnectJob {
  private:
   // ConnectJob implementation.
 
-  virtual int ConnectInternal() {
+  virtual int ConnectInternal() OVERRIDE {
     AddressList ignored;
     client_socket_factory_->CreateTransportClientSocket(
         ignored, NULL, net::NetLog::Source());
@@ -457,7 +457,7 @@ class TestConnectJobFactory
   virtual ConnectJob* NewConnectJob(
       const std::string& group_name,
       const TestClientSocketPoolBase::Request& request,
-      ConnectJob::Delegate* delegate) const {
+      ConnectJob::Delegate* delegate) const OVERRIDE {
     EXPECT_TRUE(!job_types_ || !job_types_->empty());
     TestConnectJob::JobType job_type = job_type_;
     if (job_types_ && !job_types_->empty()) {
@@ -473,7 +473,7 @@ class TestConnectJobFactory
                               net_log_);
   }
 
-  virtual base::TimeDelta ConnectionTimeout() const {
+  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
     return timeout_duration_;
   }
 
@@ -640,7 +640,7 @@ class TestConnectJobDelegate : public ConnectJob::Delegate {
       : have_result_(false), waiting_for_result_(false), result_(OK) {}
   virtual ~TestConnectJobDelegate() {}
 
-  virtual void OnConnectJobComplete(int result, ConnectJob* job) {
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE {
     result_ = result;
     scoped_ptr<StreamSocket> socket(job->ReleaseSocket());
     // socket.get() should be NULL iff result != OK
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 0b4bb8a..8d7adc1 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -237,15 +237,15 @@ class FakeSocket : public StreamSocket {
     return base::TimeDelta::FromMicroseconds(-1);
   }
 
-  virtual bool WasNpnNegotiated() const {
+  virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
 
-  virtual NextProto GetNegotiatedProtocol() const {
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
 
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/transport_client_socket_pool_unittest.cc
index 6a3d896..45b5485 100644
--- a/net/socket/transport_client_socket_pool_unittest.cc
+++ b/net/socket/transport_client_socket_pool_unittest.cc
@@ -92,23 +92,23 @@ class MockClientSocket : public StreamSocket {
   }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) {
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     connected_ = true;
     return OK;
   }
-  virtual void Disconnect() {
+  virtual void Disconnect() OVERRIDE {
     connected_ = false;
   }
-  virtual bool IsConnected() const {
+  virtual bool IsConnected() const OVERRIDE {
     return connected_;
   }
-  virtual bool IsConnectedAndIdle() const {
+  virtual bool IsConnectedAndIdle() const OVERRIDE {
     return connected_;
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const {
+  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const {
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
     if (!connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
@@ -117,39 +117,39 @@ class MockClientSocket : public StreamSocket {
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const {
+  virtual const BoundNetLog& NetLog() const OVERRIDE {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() {}
-  virtual void SetOmniboxSpeculation() {}
-  virtual bool WasEverUsed() const { return false; }
-  virtual bool UsingTCPFastOpen() const { return false; }
-  virtual int64 NumBytesRead() const { return -1; }
-  virtual base::TimeDelta GetConnectTimeMicros() const {
+  virtual void SetSubresourceSpeculation() OVERRIDE {}
+  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual bool WasEverUsed() const OVERRIDE { return false; }
+  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
+  virtual int64 NumBytesRead() const OVERRIDE { return -1; }
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE {
     return base::TimeDelta::FromMicroseconds(-1);
   }
-  virtual bool WasNpnNegotiated() const {
+  virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const {
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) {
+                   const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) {
+                    const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
-  virtual bool SetReceiveBufferSize(int32 size) { return true; }
-  virtual bool SetSendBufferSize(int32 size) { return true; }
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; }
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; }
 
  private:
   bool connected_;
@@ -165,58 +165,58 @@ class MockFailingClientSocket : public StreamSocket {
   }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) {
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     return ERR_CONNECTION_FAILED;
   }
 
-  virtual void Disconnect() {}
+  virtual void Disconnect() OVERRIDE {}
 
-  virtual bool IsConnected() const {
+  virtual bool IsConnected() const OVERRIDE {
     return false;
   }
-  virtual bool IsConnectedAndIdle() const {
+  virtual bool IsConnectedAndIdle() const OVERRIDE {
     return false;
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const {
+  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const {
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
-  virtual const BoundNetLog& NetLog() const {
+  virtual const BoundNetLog& NetLog() const OVERRIDE {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() {}
-  virtual void SetOmniboxSpeculation() {}
-  virtual bool WasEverUsed() const { return false; }
-  virtual bool UsingTCPFastOpen() const { return false; }
-  virtual int64 NumBytesRead() const { return -1; }
-  virtual base::TimeDelta GetConnectTimeMicros() const {
+  virtual void SetSubresourceSpeculation() OVERRIDE {}
+  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual bool WasEverUsed() const OVERRIDE { return false; }
+  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
+  virtual int64 NumBytesRead() const OVERRIDE { return -1; }
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE {
     return base::TimeDelta::FromMicroseconds(-1);
   }
-  virtual bool WasNpnNegotiated() const {
+  virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const {
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) {
+                   const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) {
+                    const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
-  virtual bool SetReceiveBufferSize(int32 size) { return true; }
-  virtual bool SetSendBufferSize(int32 size) { return true; }
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; }
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; }
 
  private:
   const AddressList addrlist_;
@@ -245,7 +245,7 @@ class MockPendingClientSocket : public StreamSocket {
   }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) {
+  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&MockPendingClientSocket::DoCallback,
@@ -254,18 +254,18 @@ class MockPendingClientSocket : public StreamSocket {
     return ERR_IO_PENDING;
   }
 
-  virtual void Disconnect() {}
+  virtual void Disconnect() OVERRIDE {}
 
-  virtual bool IsConnected() const {
+  virtual bool IsConnected() const OVERRIDE {
     return is_connected_;
   }
-  virtual bool IsConnectedAndIdle() const {
+  virtual bool IsConnectedAndIdle() const OVERRIDE {
     return is_connected_;
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const {
+  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
     return ERR_UNEXPECTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const {
+  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
     if (!is_connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
@@ -274,40 +274,40 @@ class MockPendingClientSocket : public StreamSocket {
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const {
+  virtual const BoundNetLog& NetLog() const OVERRIDE {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() {}
-  virtual void SetOmniboxSpeculation() {}
-  virtual bool WasEverUsed() const { return false; }
-  virtual bool UsingTCPFastOpen() const { return false; }
-  virtual int64 NumBytesRead() const { return -1; }
-  virtual base::TimeDelta GetConnectTimeMicros() const {
+  virtual void SetSubresourceSpeculation() OVERRIDE {}
+  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual bool WasEverUsed() const OVERRIDE { return false; }
+  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
+  virtual int64 NumBytesRead() const OVERRIDE { return -1; }
+  virtual base::TimeDelta GetConnectTimeMicros() const OVERRIDE {
     return base::TimeDelta::FromMicroseconds(-1);
   }
-  virtual bool WasNpnNegotiated() const {
+  virtual bool WasNpnNegotiated() const OVERRIDE {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const {
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     return false;
   }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) {
+                   const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) {
+                    const CompletionCallback& callback) OVERRIDE {
     return ERR_FAILED;
   }
-  virtual bool SetReceiveBufferSize(int32 size) { return true; }
-  virtual bool SetSendBufferSize(int32 size) { return true; }
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; }
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; }
 
  private:
   void DoCallback(const CompletionCallback& callback) {
@@ -356,7 +356,7 @@ 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 {
     NOTREACHED();
     return NULL;
   }
@@ -364,7 +364,7 @@ class MockClientSocketFactory : public ClientSocketFactory {
   virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
-      const NetLog::Source& /* source */) {
+      const NetLog::Source& /* source */) OVERRIDE {
     allocation_count_++;
 
     ClientSocketType type = client_socket_type_;
@@ -400,12 +400,12 @@ class MockClientSocketFactory : public ClientSocketFactory {
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) {
+      const SSLClientSocketContext& context) OVERRIDE {
     NOTIMPLEMENTED();
     return NULL;
   }
 
-  virtual void ClearSSLSessionCache() {
+  virtual void ClearSSLSessionCache() OVERRIDE {
     NOTIMPLEMENTED();
   }
 
@@ -460,7 +460,7 @@ class TransportClientSocketPoolTest : public testing::Test {
               NULL) {
   }
 
-  ~TransportClientSocketPoolTest() {
+  virtual ~TransportClientSocketPoolTest() {
     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         connect_backup_jobs_enabled_);
   }
diff --git a/net/socket/transport_client_socket_unittest.cc b/net/socket/transport_client_socket_unittest.cc
index a7a6edf..73136ae 100644
--- a/net/socket/transport_client_socket_unittest.cc
+++ b/net/socket/transport_client_socket_unittest.cc
@@ -43,22 +43,22 @@ class TransportClientSocketTest
         close_server_socket_on_next_send_(false) {
   }
 
-  ~TransportClientSocketTest() {
+  virtual ~TransportClientSocketTest() {
   }
 
   // Implement StreamListenSocket::Delegate methods
   virtual void DidAccept(StreamListenSocket* server,
-                         StreamListenSocket* connection) {
+                         StreamListenSocket* connection) OVERRIDE {
     connected_sock_ = reinterpret_cast<TCPListenSocket*>(connection);
   }
-  virtual void DidRead(StreamListenSocket*, const char* str, int len) {
+  virtual void DidRead(StreamListenSocket*, const char* str, int len) OVERRIDE {
     // TODO(dkegel): this might not be long enough to tickle some bugs.
     connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1,
                           false /* Don't append line feed */);
     if (close_server_socket_on_next_send_)
       CloseServerSocket();
   }
-  virtual void DidClose(StreamListenSocket* sock) {}
+  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
 
   // Testcase hooks
   virtual void SetUp();
diff --git a/net/spdy/buffered_spdy_framer_spdy2_unittest.cc b/net/spdy/buffered_spdy_framer_spdy2_unittest.cc
index 4bbdf6e..a3ea858 100644
--- a/net/spdy/buffered_spdy_framer_spdy2_unittest.cc
+++ b/net/spdy/buffered_spdy_framer_spdy2_unittest.cc
@@ -25,70 +25,76 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
         header_stream_id_(-1) {
   }
 
-  void OnError(SpdyFramer::SpdyError error_code) {
+  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
-  void OnStreamError(SpdyStreamId stream_id,
-                     const std::string& description) {
+  virtual void OnStreamError(
+      SpdyStreamId stream_id,
+      const std::string& description) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
               << description;
     error_count_++;
   }
 
-  void OnSynStream(SpdyStreamId stream_id,
-                   SpdyStreamId associated_stream_id,
-                   SpdyPriority priority,
-                   uint8 credential_slot,
-                   bool fin,
-                   bool unidirectional,
-                   const SpdyHeaderBlock& headers) {
+  virtual void OnSynStream(SpdyStreamId stream_id,
+                           SpdyStreamId associated_stream_id,
+                           SpdyPriority priority,
+                           uint8 credential_slot,
+                           bool fin,
+                           bool unidirectional,
+                           const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_frame_count_++;
     headers_ = headers;
   }
 
-  void OnSynReply(SpdyStreamId stream_id,
-                  bool fin,
-                  const SpdyHeaderBlock& headers) {
+  virtual void OnSynReply(SpdyStreamId stream_id,
+                          bool fin,
+                          const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_reply_frame_count_++;
     headers_ = headers;
   }
 
-  void OnHeaders(SpdyStreamId stream_id,
-                 bool fin,
-                 const SpdyHeaderBlock& headers) {
+  virtual void OnHeaders(SpdyStreamId stream_id,
+                         bool fin,
+                         const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     headers_frame_count_++;
     headers_ = headers;
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
-                         size_t len,
-                         SpdyDataFlags flags) {
+  virtual void OnStreamFrameData(SpdyStreamId stream_id,
+                                 const char* data,
+                                 size_t len,
+                                 SpdyDataFlags flags) OVERRIDE {
     LOG(FATAL) << "Unexpected OnStreamFrameData call.";
   }
 
-  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE {
     setting_count_++;
   }
 
-  void OnPing(uint32 unique_id) {}
+  virtual void OnPing(uint32 unique_id) OVERRIDE {}
 
-  void OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {}
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyStatusCodes status) OVERRIDE {
+  }
 
-  void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status) {}
+  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                        SpdyGoAwayStatus status) OVERRIDE {
+  }
 
-  void OnControlFrameCompressed(
+  virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
-      const SpdyControlFrame& compressed_frame) {
+      const SpdyControlFrame& compressed_frame) OVERRIDE {
   }
 
   bool OnCredentialFrameData(const char*, size_t) {
@@ -103,7 +109,9 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
   void OnRstStream(const SpdyRstStreamControlFrame& frame) {}
   void OnGoAway(const SpdyGoAwayControlFrame& frame) {}
   void OnPing(const SpdyPingControlFrame& frame) {}
-  void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {}
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) OVERRIDE {
+  }
   void OnCredential(const SpdyCredentialControlFrame& frame) {}
 
   // Convenience function which runs a framer simulation with particular input.
diff --git a/net/spdy/buffered_spdy_framer_spdy3_unittest.cc b/net/spdy/buffered_spdy_framer_spdy3_unittest.cc
index ca9edf3..777b49c 100644
--- a/net/spdy/buffered_spdy_framer_spdy3_unittest.cc
+++ b/net/spdy/buffered_spdy_framer_spdy3_unittest.cc
@@ -25,70 +25,74 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
         header_stream_id_(-1) {
   }
 
-  void OnError(SpdyFramer::SpdyError error_code) {
+  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
-  void OnStreamError(SpdyStreamId stream_id,
-                     const std::string& description) {
+  virtual void OnStreamError(SpdyStreamId stream_id,
+                             const std::string& description) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
               << description;
     error_count_++;
   }
 
-  void OnSynStream(SpdyStreamId stream_id,
-                   SpdyStreamId associated_stream_id,
-                   SpdyPriority priority,
-                   uint8 credential_slot,
-                   bool fin,
-                   bool unidirectional,
-                   const SpdyHeaderBlock& headers) {
+  virtual void OnSynStream(SpdyStreamId stream_id,
+                           SpdyStreamId associated_stream_id,
+                           SpdyPriority priority,
+                           uint8 credential_slot,
+                           bool fin,
+                           bool unidirectional,
+                           const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_frame_count_++;
     headers_ = headers;
   }
 
-  void OnSynReply(SpdyStreamId stream_id,
-                  bool fin,
-                  const SpdyHeaderBlock& headers) {
+  virtual void OnSynReply(SpdyStreamId stream_id,
+                          bool fin,
+                          const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_reply_frame_count_++;
     headers_ = headers;
   }
 
-  void OnHeaders(SpdyStreamId stream_id,
-                 bool fin,
-                 const SpdyHeaderBlock& headers) {
+  virtual void OnHeaders(SpdyStreamId stream_id,
+                         bool fin,
+                         const SpdyHeaderBlock& headers) OVERRIDE {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     headers_frame_count_++;
     headers_ = headers;
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
-                         size_t len,
-                         SpdyDataFlags flags) {
+  virtual void OnStreamFrameData(SpdyStreamId stream_id,
+                                 const char* data,
+                                 size_t len,
+                                 SpdyDataFlags flags) OVERRIDE {
     LOG(FATAL) << "Unexpected OnStreamFrameData call.";
   }
 
-  void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE {
     setting_count_++;
   }
 
-  void OnPing(uint32 unique_id) {}
+  virtual void OnPing(uint32 unique_id) OVERRIDE {}
 
-  void OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {}
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyStatusCodes status) OVERRIDE {}
 
-  void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status) {}
+  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                        SpdyGoAwayStatus status) OVERRIDE {
+  }
 
-  void OnControlFrameCompressed(
+  virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
-      const SpdyControlFrame& compressed_frame) {
+      const SpdyControlFrame& compressed_frame) OVERRIDE {
   }
 
   bool OnCredentialFrameData(const char*, size_t) {
@@ -103,7 +107,9 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
   void OnRstStream(const SpdyRstStreamControlFrame& frame) {}
   void OnGoAway(const SpdyGoAwayControlFrame& frame) {}
   void OnPing(const SpdyPingControlFrame& frame) {}
-  void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {}
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) OVERRIDE {
+  }
   void OnCredential(const SpdyCredentialControlFrame& frame) {}
 
   // Convenience function which runs a framer simulation with particular input.
diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc
index 98320f6..c1ab756 100644
--- a/net/spdy/spdy_framer_test.cc
+++ b/net/spdy/spdy_framer_test.cc
@@ -101,7 +101,7 @@ class SpdyFramerTestUtil {
                              SpdyPriority priority,
                              uint8 slot,
                              bool fin,
-                             bool unidirectional) {
+                             bool unidirectional) OVERRIDE {
       SpdyFramer framer(version_);
       const SpdyHeaderBlock null_headers;
       int flags = CONTROL_FLAG_NONE;
@@ -124,7 +124,7 @@ class SpdyFramerTestUtil {
       size_ += SpdySynStreamControlFrame::size();
     }
 
-    virtual void OnSynReply(SpdyStreamId stream_id, bool fin) {
+    virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
       SpdyFramer framer(version_);
       const SpdyHeaderBlock null_headers;
       int flags = CONTROL_FLAG_NONE;
@@ -141,7 +141,7 @@ class SpdyFramerTestUtil {
       size_ += SpdySynStreamControlFrame::size();
     }
 
-    virtual void OnHeaders(SpdyStreamId stream_id, bool fin) {
+    virtual void OnHeaders(SpdyStreamId stream_id, bool fin) OVERRIDE {
       SpdyFramer framer(version_);
       const SpdyHeaderBlock null_headers;
       int flags = CONTROL_FLAG_NONE;
@@ -160,7 +160,7 @@ class SpdyFramerTestUtil {
 
     virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                           const char* header_data,
-                                          size_t len) {
+                                          size_t len) OVERRIDE {
       CHECK(buffer_.get() != NULL);
       CHECK_GE(kMaxDecompressedSize, size_ + len);
       CHECK(!finished_);
@@ -175,39 +175,43 @@ class SpdyFramerTestUtil {
     }
 
     virtual bool OnCredentialFrameData(const char* header_data,
-                                       size_t len) {
+                                       size_t len) OVERRIDE {
       LOG(FATAL) << "Unexpected CREDENTIAL Frame";
       return false;
     }
 
-    virtual void OnError(SpdyFramer* framer) { LOG(FATAL); }
-    virtual void OnDataFrameHeader(const SpdyDataFrame* frame) {
+    virtual void OnError(SpdyFramer* framer) OVERRIDE { LOG(FATAL); }
+    virtual void OnDataFrameHeader(const SpdyDataFrame* frame) OVERRIDE {
       LOG(FATAL) << "Unexpected data frame header";
     }
     virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                    const char* data,
                                    size_t len,
-                                   SpdyDataFlags flags) {
+                                   SpdyDataFlags flags) OVERRIDE {
       LOG(FATAL);
     }
-    virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
+    virtual void OnSetting(SpdySettingsIds id,
+                           uint8 flags,
+                           uint32 value) OVERRIDE {
       LOG(FATAL);
     }
     virtual void OnControlFrameCompressed(
         const SpdyControlFrame& uncompressed_frame,
-        const SpdyControlFrame& compressed_frame) {
+        const SpdyControlFrame& compressed_frame) OVERRIDE {
     }
-    virtual void OnPing(uint32 unique_id) {
+    virtual void OnPing(uint32 unique_id) OVERRIDE {
       LOG(FATAL);
     }
-    virtual void OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {
+    virtual void OnRstStream(SpdyStreamId stream_id,
+                             SpdyStatusCodes status) OVERRIDE {
       LOG(FATAL);
     }
     virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                          SpdyGoAwayStatus status) {
+                          SpdyGoAwayStatus status) OVERRIDE {
       LOG(FATAL);
     }
-    virtual void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {
+    virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                                int delta_window_size) OVERRIDE {
       LOG(FATAL);
     }
 
@@ -233,8 +237,10 @@ class SpdyFramerTestUtil {
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
 };
 
-string HexDumpWithMarks(const unsigned char* data, int length,
-                             const bool* marks, int mark_length) {
+string HexDumpWithMarks(const unsigned char* data,
+                        int length,
+                        const bool* marks,
+                        int mark_length) {
   static const char kHexChars[] = "0123456789abcdef";
   static const int kColumns = 4;
 
@@ -334,21 +340,21 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
       credential_buffer_size_(kDefaultCredentialBufferSize) {
   }
 
-  void OnError(SpdyFramer* f) {
+  virtual void OnError(SpdyFramer* f) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
     error_count_++;
   }
 
-  void OnDataFrameHeader(const SpdyDataFrame* frame) {
+  virtual void OnDataFrameHeader(const SpdyDataFrame* frame) OVERRIDE {
     data_frame_count_++;
     header_stream_id_ = frame->stream_id();
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
-                         size_t len,
-                         SpdyDataFlags flags) {
+  virtual void OnStreamFrameData(SpdyStreamId stream_id,
+                                 const char* data,
+                                 size_t len,
+                                 SpdyDataFlags flags) OVERRIDE {
     EXPECT_EQ(header_stream_id_, stream_id);
     if (len == 0)
       ++zero_length_data_frame_count_;
@@ -368,7 +374,7 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
                            SpdyPriority priority,
                            uint8 credential_slot,
                            bool fin,
-                           bool unidirectional) {
+                           bool unidirectional) OVERRIDE {
     syn_frame_count_++;
     InitHeaderStreaming(SYN_STREAM, stream_id);
     if (fin) {
@@ -376,7 +382,7 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
     }
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) {
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
     syn_reply_frame_count_++;
     InitHeaderStreaming(HEADERS, stream_id);
     if (fin) {
@@ -384,7 +390,7 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
     }
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin) {
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin) OVERRIDE {
     headers_frame_count_++;
     InitHeaderStreaming(SYN_REPLY, stream_id);
     if (fin) {
@@ -392,36 +398,40 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
     }
   }
 
-  virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE {
     setting_count_++;
   }
 
   virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
-      const SpdyControlFrame& compressed_frame) {
+      const SpdyControlFrame& compressed_frame) OVERRIDE {
   }
 
-  virtual void OnPing(uint32 unique_id) {
+  virtual void OnPing(uint32 unique_id) OVERRIDE {
     DLOG(FATAL);
   }
 
-  virtual void OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyStatusCodes status) OVERRIDE {
     fin_frame_count_++;
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) {
+                        SpdyGoAwayStatus status) OVERRIDE {
     goaway_count_++;
   }
 
-  virtual void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) OVERRIDE {
     last_window_update_stream_ = stream_id;
     last_window_update_delta_ = delta_window_size;
   }
 
-  bool OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                const char* header_data,
-                                size_t len) {
+  virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
+                                        const char* header_data,
+                                        size_t len) OVERRIDE {
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
@@ -443,8 +453,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
     return true;
   }
 
-  bool OnCredentialFrameData(const char* credential_data,
-                             size_t len) {
+  virtual bool OnCredentialFrameData(const char* credential_data,
+                                     size_t len) OVERRIDE {
     if (len == 0) {
       if (!framer_.ParseCredentialData(credential_buffer_.get(),
                                        credential_buffer_length_,
diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc
index f9a9997..aa544e9 100644
--- a/net/spdy/spdy_session_spdy2_unittest.cc
+++ b/net/spdy/spdy_session_spdy2_unittest.cc
@@ -111,7 +111,7 @@ class SpdySessionSpdy2Test : public PlatformTest {
         pair_(test_host_port_pair_, ProxyServer::Direct()) {
   }
 
-  void SetUp() {
+  virtual void SetUp() {
     g_delta_seconds = 0;
   }
 
diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc
index 96fe20b..8fd1ab1 100644
--- a/net/spdy/spdy_session_spdy3_unittest.cc
+++ b/net/spdy/spdy_session_spdy3_unittest.cc
@@ -111,7 +111,7 @@ class SpdySessionSpdy3Test : public PlatformTest {
         pair_(test_host_port_pair_, ProxyServer::Direct()) {
   }
 
-  void SetUp() {
+  virtual void SetUp() {
     g_delta_seconds = 0;
   }
 
diff --git a/net/spdy/spdy_websocket_stream_spdy2_unittest.cc b/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
index 20b7217..0b84fb4 100644
--- a/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_websocket_stream_spdy2_unittest.cc
@@ -76,7 +76,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     on_close_ = callback;
   }
 
-  virtual void OnCreatedSpdyStream(int result) {
+  virtual void OnCreatedSpdyStream(int result) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
                                  SpdyHeaderBlock(),
@@ -85,7 +85,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_created_.is_null())
       on_created_.Run(&events_.back());
   }
-  virtual void OnSentSpdyHeaders(int result) {
+  virtual void OnSentSpdyHeaders(int result) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
                                  SpdyHeaderBlock(),
@@ -95,7 +95,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
       on_sent_data_.Run(&events_.back());
   }
   virtual int OnReceivedSpdyResponseHeader(
-      const SpdyHeaderBlock& headers, int status) {
+      const SpdyHeaderBlock& headers, int status) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
@@ -106,7 +106,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
       on_received_header_.Run(&events_.back());
     return status;
   }
-  virtual void OnSentSpdyData(int amount_sent) {
+  virtual void OnSentSpdyData(int amount_sent) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
@@ -116,7 +116,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnReceivedSpdyData(const char* data, int length) {
+  virtual void OnReceivedSpdyData(const char* data, int length) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
@@ -126,7 +126,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnCloseSpdyStream() {
+  virtual void OnCloseSpdyStream() OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_CLOSE,
diff --git a/net/spdy/spdy_websocket_stream_spdy3_unittest.cc b/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
index 932d0a0..826c114 100644
--- a/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_websocket_stream_spdy3_unittest.cc
@@ -76,7 +76,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     on_close_ = callback;
   }
 
-  virtual void OnCreatedSpdyStream(int result) {
+  virtual void OnCreatedSpdyStream(int result) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
                                  SpdyHeaderBlock(),
@@ -85,7 +85,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_created_.is_null())
       on_created_.Run(&events_.back());
   }
-  virtual void OnSentSpdyHeaders(int result) {
+  virtual void OnSentSpdyHeaders(int result) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
                                  SpdyHeaderBlock(),
@@ -95,7 +95,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
       on_sent_data_.Run(&events_.back());
   }
   virtual int OnReceivedSpdyResponseHeader(
-      const SpdyHeaderBlock& headers, int status) {
+      const SpdyHeaderBlock& headers, int status) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
@@ -106,7 +106,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
       on_received_header_.Run(&events_.back());
     return status;
   }
-  virtual void OnSentSpdyData(int amount_sent) {
+  virtual void OnSentSpdyData(int amount_sent) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
@@ -116,7 +116,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnReceivedSpdyData(const char* data, int length) {
+  virtual void OnReceivedSpdyData(const char* data, int length) OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
@@ -126,7 +126,7 @@ class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnCloseSpdyStream() {
+  virtual void OnCloseSpdyStream() OVERRIDE {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_CLOSE,
diff --git a/net/tools/flip_server/epoll_server.cc b/net/tools/flip_server/epoll_server.cc
index 51d58c8..522dfed 100644
--- a/net/tools/flip_server/epoll_server.cc
+++ b/net/tools/flip_server/epoll_server.cc
@@ -60,7 +60,7 @@ namespace net {
 // Clears the pipe and returns.  Used for waking the epoll server up.
 class ReadPipeCallback : public EpollCallbackInterface {
  public:
-  void OnEvent(int fd, EpollEvent* event) {
+  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE {
     DCHECK(event->in_events == EPOLLIN);
     int data;
     int data_read = 1;
@@ -69,10 +69,10 @@ class ReadPipeCallback : public EpollCallbackInterface {
       data_read = read(fd, &data, sizeof(data));
     }
   }
-  void OnShutdown(EpollServer *eps, int fd) {}
-  void OnRegistration(EpollServer*, int, int) {}
-  void OnModification(int, int) {}       // COV_NF_LINE
-  void OnUnregistration(int, bool) {}    // COV_NF_LINE
+  virtual void OnShutdown(EpollServer *eps, int fd) OVERRIDE {}
+  virtual void OnRegistration(EpollServer*, int, int) OVERRIDE {}
+  virtual void OnModification(int, int) OVERRIDE {}       // COV_NF_LINE
+  virtual void OnUnregistration(int, bool) OVERRIDE {}    // COV_NF_LINE
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/net/url_request/url_request_ftp_job_unittest.cc b/net/url_request/url_request_ftp_job_unittest.cc
index c960b8e..7647b3f 100644
--- a/net/url_request/url_request_ftp_job_unittest.cc
+++ b/net/url_request/url_request_ftp_job_unittest.cc
@@ -72,7 +72,7 @@ class URLRequestFtpJobTest : public testing::Test {
                          &network_delegate_) {
   }
 
-  ~URLRequestFtpJobTest() {
+  virtual ~URLRequestFtpJobTest() {
     // Clean up any remaining tasks that mess up unrelated tests.
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
diff --git a/net/url_request/url_request_throttler_simulation_unittest.cc b/net/url_request/url_request_throttler_simulation_unittest.cc
index 48b0319..abc54fc 100644
--- a/net/url_request/url_request_throttler_simulation_unittest.cc
+++ b/net/url_request/url_request_throttler_simulation_unittest.cc
@@ -411,14 +411,14 @@ class Requester : public DiscreteTimeSimulation::Actor {
     DCHECK(server_);
   }
 
-  void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
+  virtual void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
     if (time_of_last_success_.is_null())
       time_of_last_success_ = absolute_time;
 
     throttler_entry_->SetFakeNow(absolute_time);
   }
 
-  void PerformAction() OVERRIDE {
+  virtual void PerformAction() OVERRIDE {
     TimeDelta effective_delay = time_between_requests_;
     TimeDelta current_jitter = TimeDelta::FromMilliseconds(
         request_jitter_.InMilliseconds() * base::RandDouble());
diff --git a/net/url_request/url_request_throttler_unittest.cc b/net/url_request/url_request_throttler_unittest.cc
index 221d0c8..998fb06 100644
--- a/net/url_request/url_request_throttler_unittest.cc
+++ b/net/url_request/url_request_throttler_unittest.cc
@@ -64,11 +64,11 @@ class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
     backoff_policy_.num_errors_to_ignore = 0;
   }
 
-  const BackoffEntry* GetBackoffEntry() const {
+  virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
     return &mock_backoff_entry_;
   }
 
-  BackoffEntry* GetBackoffEntry() {
+  virtual BackoffEntry* GetBackoffEntry() OVERRIDE {
     return &mock_backoff_entry_;
   }
 
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index ce75ff3..e63b3fe 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -895,11 +895,11 @@ class RestartTestJob : public URLRequestTestJob {
   RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() {
+  virtual void StartAsync() OVERRIDE {
     this->NotifyRestartRequired();
   }
  private:
-  ~RestartTestJob() {}
+  virtual ~RestartTestJob() {}
 };
 
 class CancelTestJob : public URLRequestTestJob {
@@ -907,11 +907,11 @@ class CancelTestJob : public URLRequestTestJob {
   explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() {
+  virtual void StartAsync() OVERRIDE {
     request_->Cancel();
   }
  private:
-  ~CancelTestJob() {}
+  virtual ~CancelTestJob() {}
 };
 
 class CancelThenRestartTestJob : public URLRequestTestJob {
@@ -921,12 +921,12 @@ class CancelThenRestartTestJob : public URLRequestTestJob {
       : URLRequestTestJob(request, network_delegate, true) {
   }
  protected:
-  virtual void StartAsync() {
+  virtual void StartAsync() OVERRIDE {
     request_->Cancel();
     this->NotifyRestartRequired();
   }
  private:
-  ~CancelThenRestartTestJob() {}
+  virtual ~CancelThenRestartTestJob() {}
 };
 
 // An Interceptor for use with interceptor tests
@@ -946,12 +946,13 @@ class TestInterceptor : URLRequest::Interceptor {
     URLRequest::Deprecated::RegisterRequestInterceptor(this);
   }
 
-  ~TestInterceptor() {
+  virtual ~TestInterceptor() {
     URLRequest::Deprecated::UnregisterRequestInterceptor(this);
   }
 
-  virtual URLRequestJob* MaybeIntercept(URLRequest* request,
-                                        NetworkDelegate* network_delegate) {
+  virtual URLRequestJob* MaybeIntercept(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) OVERRIDE {
     if (restart_main_request_) {
       restart_main_request_ = false;
       did_restart_main_ = true;
@@ -987,7 +988,7 @@ class TestInterceptor : URLRequest::Interceptor {
   virtual URLRequestJob* MaybeInterceptRedirect(
       URLRequest* request,
       NetworkDelegate* network_delegate,
-      const GURL& location) {
+      const GURL& location) OVERRIDE {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
@@ -1005,7 +1006,7 @@ class TestInterceptor : URLRequest::Interceptor {
   }
 
   virtual URLRequestJob* MaybeInterceptResponse(
-      URLRequest* request, NetworkDelegate* network_delegate) {
+      URLRequest* request, NetworkDelegate* network_delegate) OVERRIDE {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
@@ -3034,9 +3035,9 @@ const char kExtraHeader[] = "Allow-Snafu";
 const char kExtraValue[] = "fubar";
 
 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
-  void OnReceivedRedirect(net::URLRequest* request,
-                          const GURL& new_url,
-                          bool* defer_redirect) {
+  virtual void OnReceivedRedirect(net::URLRequest* request,
+                                  const GURL& new_url,
+                                  bool* defer_redirect) OVERRIDE {
     TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
@@ -3070,9 +3071,9 @@ namespace {
 const char kExtraHeaderToRemove[] = "To-Be-Removed";
 
 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
-  void OnReceivedRedirect(net::URLRequest* request,
+  virtual void OnReceivedRedirect(net::URLRequest* request,
                           const GURL& new_url,
-                          bool* defer_redirect) {
+                          bool* defer_redirect) OVERRIDE {
     TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
@@ -4457,7 +4458,7 @@ class SSLClientAuthTestDelegate : public TestDelegate {
   }
   virtual void OnCertificateRequested(
       URLRequest* request,
-      SSLCertRequestInfo* cert_request_info) {
+      SSLCertRequestInfo* cert_request_info) OVERRIDE {
     on_certificate_requested_count_++;
     MessageLoop::current()->Quit();
   }
@@ -4734,7 +4735,7 @@ class HTTPSOCSPTest : public HTTPSRequestTest {
     *out_cert_status = r.ssl_info().cert_status;
   }
 
-  ~HTTPSOCSPTest() {
+  virtual ~HTTPSOCSPTest() {
 #if defined(USE_NSS) || defined(OS_IOS)
     ShutdownNSSHttpIO();
 #endif
diff --git a/net/websockets/websocket_frame_unittest.cc b/net/websockets/websocket_frame_unittest.cc
index e0972a7..6934fad 100644
--- a/net/websockets/websocket_frame_unittest.cc
+++ b/net/websockets/websocket_frame_unittest.cc
@@ -369,7 +369,7 @@ class WebSocketFrameTestMaskBenchmark : public testing::Test {
   WebSocketFrameTestMaskBenchmark()
       : iterations_(kDefaultIterations) {}
 
-  void SetUp() {
+  virtual void SetUp() {
     std::string iterations(
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             kBenchmarkIterations));
diff --git a/net/websockets/websocket_job_spdy2_unittest.cc b/net/websockets/websocket_job_spdy2_unittest.cc
index 5ac3a9a..6af4df6 100644
--- a/net/websockets/websocket_job_spdy2_unittest.cc
+++ b/net/websockets/websocket_job_spdy2_unittest.cc
@@ -119,7 +119,7 @@ class MockSocketStreamDelegate : public net::SocketStream::Delegate {
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(net::SocketStream* socket) {
+  virtual void OnClose(net::SocketStream* socket) OVERRIDE {
     if (!on_close_.is_null())
       on_close_.Run();
   }
diff --git a/net/websockets/websocket_job_spdy3_unittest.cc b/net/websockets/websocket_job_spdy3_unittest.cc
index 3fdb8f8..cfaf515 100644
--- a/net/websockets/websocket_job_spdy3_unittest.cc
+++ b/net/websockets/websocket_job_spdy3_unittest.cc
@@ -123,7 +123,7 @@ class MockSocketStreamDelegate : public net::SocketStream::Delegate {
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(net::SocketStream* socket) {
+  virtual void OnClose(net::SocketStream* socket) OVERRIDE {
     if (!on_close_.is_null())
       on_close_.Run();
   }
@@ -306,16 +306,17 @@ class MockHttpTransactionFactory : public net::HttpTransactionFactory {
     EXPECT_EQ(net::OK,
               session_->InitializeWithSocket(connection, false, net::OK));
   }
-  virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans,
-                                net::HttpTransactionDelegate* delegate) {
+  virtual int CreateTransaction(
+      scoped_ptr<net::HttpTransaction>* trans,
+      net::HttpTransactionDelegate* delegate) OVERRIDE {
     NOTREACHED();
     return net::ERR_UNEXPECTED;
   }
-  virtual net::HttpCache* GetCache() {
+  virtual net::HttpCache* GetCache() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
-  virtual net::HttpNetworkSession* GetSession() {
+  virtual net::HttpNetworkSession* GetSession() OVERRIDE {
     return http_session_.get();
   }
  private:
diff --git a/net/websockets/websocket_throttle_unittest.cc b/net/websockets/websocket_throttle_unittest.cc
index ef05c4c..8778ffa 100644
--- a/net/websockets/websocket_throttle_unittest.cc
+++ b/net/websockets/websocket_throttle_unittest.cc
@@ -21,11 +21,12 @@ class DummySocketStreamDelegate : public net::SocketStream::Delegate {
   DummySocketStreamDelegate() {}
   virtual ~DummySocketStreamDelegate() {}
   virtual void OnConnected(
-      net::SocketStream* socket, int max_pending_send_allowed) {}
-  virtual void OnSentData(net::SocketStream* socket, int amount_sent) {}
+      net::SocketStream* socket, int max_pending_send_allowed) OVERRIDE {}
+  virtual void OnSentData(net::SocketStream* socket,
+                          int amount_sent) OVERRIDE {}
   virtual void OnReceivedData(net::SocketStream* socket,
-                              const char* data, int len) {}
-  virtual void OnClose(net::SocketStream* socket) {}
+                              const char* data, int len) OVERRIDE {}
+  virtual void OnClose(net::SocketStream* socket) OVERRIDE {}
 };
 
 namespace net {