Standardize usage of virtual/override/final in net/

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/proxy/proxy_service.h"
 
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 // TODO(eroman): Write a test which exercises
 //              ProxyService::SuspendAllPendingRequests().
 namespace net {
 namespace {
 
 // This polling policy will decide to poll every 1 ms.
 class ImmediatePollPolicy : public ProxyService::PacPollPolicy {
  public:
   ImmediatePollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const override {
+  Mode GetNextDelay(int error,
+                    base::TimeDelta current_delay,
+                    base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta::FromMilliseconds(1);
     return MODE_USE_TIMER;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImmediatePollPolicy);
 };
 
 // This polling policy chooses a fantastically large delay. In other words, it
 // will never trigger a poll
 class NeverPollPolicy : public ProxyService::PacPollPolicy {
  public:
   NeverPollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const override {
+  Mode GetNextDelay(int error,
+                    base::TimeDelta current_delay,
+                    base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta::FromDays(60);
     return MODE_USE_TIMER;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NeverPollPolicy);
 };
 
 // This polling policy starts a poll immediately after network activity.
 class ImmediateAfterActivityPollPolicy : public ProxyService::PacPollPolicy {
  public:
   ImmediateAfterActivityPollPolicy() {}
 
-  virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const override {
+  Mode GetNextDelay(int error,
+                    base::TimeDelta current_delay,
+                    base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta();
     return MODE_START_AFTER_ACTIVITY;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImmediateAfterActivityPollPolicy);
 };
 
 // This test fixture is used to partially disable the background polling done by
 // the ProxyService (which it uses to detect whenever its PAC script contents or
@@ skipping 37 matching lines @@
   explicit MockProxyConfigService(const ProxyConfig& config)
       : availability_(CONFIG_VALID),
         config_(config) {
   }
 
   explicit MockProxyConfigService(const std::string& pac_url)
       : availability_(CONFIG_VALID),
         config_(ProxyConfig::CreateFromCustomPacURL(GURL(pac_url))) {
   }
 
-  virtual void AddObserver(Observer* observer) override {
+  void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) override {
+  void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* results)
-      override {
+  ConfigAvailability GetLatestProxyConfig(ProxyConfig* results) override {
     if (availability_ == CONFIG_VALID)
       *results = config_;
     return availability_;
   }
 
   void SetConfig(const ProxyConfig& config) {
     availability_ = CONFIG_VALID;
     config_ = config;
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnProxyConfigChanged(config_, availability_));
   }
 
  private:
   ConfigAvailability availability_;
   ProxyConfig config_;
   ObserverList<Observer, true> observers_;
 };
 
 // A test network delegate that exercises the OnResolveProxy callback.
 class TestResolveProxyNetworkDelegate : public NetworkDelegate {
  public:
   TestResolveProxyNetworkDelegate()
       : on_resolve_proxy_called_(false),
         add_proxy_(false),
         remove_proxy_(false),
         proxy_service_(NULL) {
   }
 
-  virtual void OnResolveProxy(const GURL& url,
-                              int load_flags,
-                              const ProxyService& proxy_service,
-                              ProxyInfo* result) override {
+  void OnResolveProxy(const GURL& url,
+                      int load_flags,
+                      const ProxyService& proxy_service,
+                      ProxyInfo* result) override {
     on_resolve_proxy_called_ = true;
     proxy_service_ = &proxy_service;
     DCHECK(!add_proxy_ || !remove_proxy_);
     if (add_proxy_) {
       result->UseNamedProxy("delegate_proxy.com");
     } else if (remove_proxy_) {
       result->UseDirect();
     }
   }
 
@@ skipping 21 matching lines @@
 };
 
 // A test network delegate that exercises the OnProxyFallback callback.
 class TestProxyFallbackNetworkDelegate : public NetworkDelegate {
  public:
   TestProxyFallbackNetworkDelegate()
       : on_proxy_fallback_called_(false),
         proxy_fallback_net_error_(OK) {
   }
 
-  virtual void OnProxyFallback(const ProxyServer& proxy_server,
-                               int net_error) override {
+  void OnProxyFallback(const ProxyServer& proxy_server,
+                       int net_error) override {
     proxy_server_ = proxy_server;
     proxy_fallback_net_error_ = net_error;
     on_proxy_fallback_called_ = true;
   }
 
   bool on_proxy_fallback_called() const {
     return on_proxy_fallback_called_;
   }
 
   const ProxyServer& proxy_server() const {
@@ skipping 2902 matching lines @@
       url, net::LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_TRUE(synchronous_success);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
 
   // No request should have been queued.
   EXPECT_EQ(0u, resolver->pending_requests().size());
 }
 
 }  // namespace net