diff options
| author | rsleevi@chromium.org <rsleevi@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-02-06 09:40:16 +0000 |
|---|---|---|
| committer | rsleevi@chromium.org <rsleevi@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-02-06 09:40:16 +0000 |
| commit | 46fadfdbbc627b0002df90c702032030e6dc50f2 (patch) | |
| tree | 6148779094fc12880579ecc7cf67bfd768970a41 /net | |
| parent | ef8175fff059f8e32ee103df3f348f4e515c7e80 (diff) | |
| download | chromium_src-46fadfdbbc627b0002df90c702032030e6dc50f2.zip chromium_src-46fadfdbbc627b0002df90c702032030e6dc50f2.tar.gz chromium_src-46fadfdbbc627b0002df90c702032030e6dc50f2.tar.bz2 | |
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
Diffstat (limited to 'net')
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 { |