replace OVERRIDE and FINAL with override and final in net/

net/proxy/proxy_service.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 103 matching lines @@
 // network.proxy.autoconfig_retry_interval_max. The defaults are 5 seconds and
 // 5 minutes respectively. It doubles the interval at each attempt.
 //
 // TODO(eroman): Figure out what Internet Explorer does.
 class DefaultPollPolicy : public ProxyService::PacPollPolicy {
  public:
   DefaultPollPolicy() {}
 
   virtual Mode GetNextDelay(int initial_error,
                             TimeDelta current_delay,
-                            TimeDelta* next_delay) const OVERRIDE {
+                            TimeDelta* next_delay) const override {
     if (initial_error != OK) {
       // Re-try policy for failures.
       const int kDelay1Seconds = 8;
       const int kDelay2Seconds = 32;
       const int kDelay3Seconds = 2 * 60;  // 2 minutes
       const int kDelay4Seconds = 4 * 60 * 60;  // 4 Hours
 
       // Initial poll.
       if (current_delay < TimeDelta()) {
         *next_delay = TimeDelta::FromSeconds(kDelay1Seconds);
@@ skipping 18 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultPollPolicy);
 };
 
 // Config getter that always returns direct settings.
 class ProxyConfigServiceDirect : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config)
-      OVERRIDE {
+      override {
     *config = ProxyConfig::CreateDirect();
     config->set_source(PROXY_CONFIG_SOURCE_UNKNOWN);
     return CONFIG_VALID;
   }
 };
 
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() : ProxyResolver(false /*expects_pac_bytes*/) {}
 
   // ProxyResolver implementation.
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     return ERR_NOT_IMPLEMENTED;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& /*script_data*/,
-      const CompletionCallback& /*callback*/) OVERRIDE {
+      const CompletionCallback& /*callback*/) override {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
 // ProxyResolver that simulates a PAC script which returns
 // |pac_string| for every single URL.
 class ProxyResolverFromPacString : public ProxyResolver {
  public:
   explicit ProxyResolverFromPacString(const std::string& pac_string)
       : ProxyResolver(false /*expects_pac_bytes*/),
         pac_string_(pac_string) {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     results->UsePacString(pac_string_);
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return OK;
   }
 
  private:
   const std::string pac_string_;
 };
 
 // Creates ProxyResolvers using a platform-specific implementation.
 class ProxyResolverFactoryForSystem : public ProxyResolverFactory {
  public:
   ProxyResolverFactoryForSystem()
       : ProxyResolverFactory(false /*expects_pac_bytes*/) {}
 
-  virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
+  virtual ProxyResolver* CreateProxyResolver() override {
     DCHECK(IsSupported());
 #if defined(OS_WIN)
     return new ProxyResolverWinHttp();
 #elif defined(OS_MACOSX)
     return new ProxyResolverMac();
 #else
     NOTREACHED();
     return NULL;
 #endif
   }
@@ skipping 42 matching lines @@
   dict->SetString("pac_string", result->ToPacString());
   return dict;
 }
 
 #if defined(OS_CHROMEOS)
 class UnsetProxyConfigService : public ProxyConfigService {
  public:
   UnsetProxyConfigService() {}
   virtual ~UnsetProxyConfigService() {}
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
   virtual ConfigAvailability GetLatestProxyConfig(
-      ProxyConfig* config) OVERRIDE {
+      ProxyConfig* config) override {
     return CONFIG_UNSET;
   }
 };
 #endif
 
 }  // namespace
 
 // ProxyService::InitProxyResolver --------------------------------------------
 
 // This glues together two asynchronous steps:
@@ skipping 1226 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net