replace OVERRIDE and FINAL with override and 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 20 matching lines @@
 //              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 {
+                            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 {
+                            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 {
+                            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
 // WPAD results have changed).
 //
 // We disable the feature by setting the poll interval to something really
 // large, so it will never actually be reached even on the slowest bots that run
 // these tests.
 //
 // We disable the polling in order to avoid any timing dependencies in the
 // tests. If the bot were to run the tests very slowly and we hadn't disabled
 // polling, then it might start a background re-try in the middle of our test
 // and confuse our expectations leading to flaky failures.
 //
 // The tests which verify the polling code re-enable the polling behavior but
 // are careful to avoid timing problems.
 class ProxyServiceTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     testing::Test::SetUp();
     previous_policy_ =
         ProxyService::set_pac_script_poll_policy(&never_poll_policy_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Restore the original policy.
     ProxyService::set_pac_script_poll_policy(previous_policy_);
     testing::Test::TearDown();
   }
 
  private:
   NeverPollPolicy never_poll_policy_;
   const ProxyService::PacPollPolicy* previous_policy_;
 };
 
 const char kValidPacScript1[] = "pac-script-v1-FindProxyForURL";
 const char kValidPacScript2[] = "pac-script-v2-FindProxyForURL";
 
 class MockProxyConfigService: public ProxyConfigService {
  public:
   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 {
+  virtual void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* results)
-      OVERRIDE {
+      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_));
@@ skipping 11 matching lines @@
   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 {
+                              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 22 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 {
+                               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 2850 matching lines @@
   ProxyInfo info3;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(
       GURL("http://request3"), net::LOAD_NORMAL, &info3, callback3.callback(),
       NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(info3.is_direct());
 }
 
 }  // namespace net