replace OVERRIDE and FINAL with override and final in net/

net/dns/dns_config_service_win.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/dns/dns_config_service_win.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 294 matching lines @@
     callback_ = callback;
     if (key_.Open(HKEY_LOCAL_MACHINE, key, KEY_NOTIFY) != ERROR_SUCCESS)
       return false;
     if (key_.StartWatching() != ERROR_SUCCESS)
       return false;
     if (!watcher_.StartWatching(key_.watch_event(), this))
       return false;
     return true;
   }
 
-  virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
+  virtual void OnObjectSignaled(HANDLE object) override {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "RegistryWatcher_OnObjectSignaled"));
 
     DCHECK(CalledOnValidThread());
     bool succeeded = (key_.StartWatching() == ERROR_SUCCESS) &&
                       watcher_.StartWatching(key_.watch_event(), this);
     if (!succeeded && key_.Valid()) {
       watcher_.StopWatching();
@@ skipping 276 matching lines @@
   }
 
  private:
   void OnHostsChanged(const base::FilePath& path, bool error) {
     if (error)
       NetworkChangeNotifier::RemoveIPAddressObserver(this);
     service_->OnHostsChanged(!error);
   }
 
   // NetworkChangeNotifier::IPAddressObserver:
-  virtual void OnIPAddressChanged() OVERRIDE {
+  virtual void OnIPAddressChanged() override {
     // Need to update non-loopback IP of local host.
     service_->OnHostsChanged(true);
   }
 
   DnsConfigServiceWin* service_;
 
   RegistryWatcher tcpip_watcher_;
   RegistryWatcher tcpip6_watcher_;
   RegistryWatcher dnscache_watcher_;
   RegistryWatcher policy_watcher_;
   base::FilePathWatcher hosts_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(Watcher);
 };
 
 // Reads config from registry and IpHelper. All work performed on WorkerPool.
 class DnsConfigServiceWin::ConfigReader : public SerialWorker {
  public:
   explicit ConfigReader(DnsConfigServiceWin* service)
       : service_(service),
         success_(false) {}
 
  private:
   virtual ~ConfigReader() {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     // Should be called on WorkerPool.
     base::TimeTicks start_time = base::TimeTicks::Now();
     DnsSystemSettings settings = {};
     ConfigParseWinResult result = ReadSystemSettings(&settings);
     if (result == CONFIG_PARSE_WIN_OK)
       result = ConvertSettingsToDnsConfig(settings, &dns_config_);
     success_ = (result == CONFIG_PARSE_WIN_OK ||
                 result == CONFIG_PARSE_WIN_UNHANDLED_OPTIONS);
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ConfigParseWin",
                               result, CONFIG_PARSE_WIN_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.ConfigParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     DCHECK(loop()->BelongsToCurrentThread());
     DCHECK(!IsCancelled());
     if (success_) {
       service_->OnConfigRead(dns_config_);
     } else {
       LOG(WARNING) << "Failed to read DnsConfig.";
       // Try again in a while in case DnsConfigWatcher missed the signal.
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&ConfigReader::WorkNow, this),
@@ skipping 13 matching lines @@
  public:
   explicit HostsReader(DnsConfigServiceWin* service)
       : path_(GetHostsPath()),
         service_(service),
         success_(false) {
   }
 
  private:
   virtual ~HostsReader() {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     HostsParseWinResult result = HOSTS_PARSE_WIN_UNREADABLE_HOSTS_FILE;
     if (ParseHostsFile(path_, &hosts_))
       result = AddLocalhostEntries(&hosts_);
     success_ = (result == HOSTS_PARSE_WIN_OK);
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.HostsParseWin",
                               result, HOSTS_PARSE_WIN_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.HostsParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     DCHECK(loop()->BelongsToCurrentThread());
     if (success_) {
       service_->OnHostsRead(hosts_);
     } else {
       LOG(WARNING) << "Failed to read DnsHosts.";
     }
   }
 
   const base::FilePath path_;
   DnsConfigServiceWin* service_;
@@ skipping 53 matching lines @@
 }
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServiceWin());
 }
 
 }  // namespace net