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
280723148 · Feb 6, 2013 · 46fadfd · 46fadfd
1 parent ef8175f
commit 46fadfd
Show file tree

Hide file tree

Showing 49 changed files with 387 additions and 348 deletions.
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -8496,15 +8496,15 @@ 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);
     resolved_.push_back(url);
     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,19 +9366,19 @@ 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);
 
     return MockRead(SYNCHRONOUS,
                     "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
@@ -8476,15 +8476,15 @@ 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);
     resolved_.push_back(url);
     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,19 +9346,19 @@ 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);
 
     return MockRead(SYNCHRONOUS,
                     "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
@@ -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
@@ -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
@@ -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
@@ -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,21 +537,22 @@ 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,
         base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, AsWeakPtr()));
     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
@@ -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
@@ -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
@@ -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
@@ -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_;