Standardize usage of virtual/override/final in net/

net/dns/dns_config_service_posix.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_posix.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 245 matching lines @@
 };
 
 // A SerialWorker that uses libresolv to initialize res_state and converts
 // it to DnsConfig (except on Android, where it reads system properties
 // net.dns1 and net.dns2; see #if around ReadDnsConfig above.)
 class DnsConfigServicePosix::ConfigReader : public SerialWorker {
  public:
   explicit ConfigReader(DnsConfigServicePosix* service)
       : service_(service), success_(false) {}
 
-  virtual void DoWork() override {
+  void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     ConfigParsePosixResult result = ReadDnsConfig(&dns_config_);
     switch (result) {
       case CONFIG_PARSE_POSIX_MISSING_OPTIONS:
       case CONFIG_PARSE_POSIX_UNHANDLED_OPTIONS:
         DCHECK(dns_config_.unhandled_options);
         // Fall through.
       case CONFIG_PARSE_POSIX_OK:
         success_ = true;
         break;
       default:
         success_ = false;
         break;
     }
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ConfigParsePosix",
                               result, CONFIG_PARSE_POSIX_MAX);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.ConfigParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.ConfigParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() override {
+  void OnWorkFinished() override {
     DCHECK(!IsCancelled());
     if (success_) {
       service_->OnConfigRead(dns_config_);
     } else {
       LOG(WARNING) << "Failed to read DnsConfig.";
     }
   }
 
  private:
-  virtual ~ConfigReader() {}
+  ~ConfigReader() override {}
 
   DnsConfigServicePosix* service_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsConfig dns_config_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigReader);
 };
 
 // A SerialWorker that reads the HOSTS file and runs Callback.
 class DnsConfigServicePosix::HostsReader : public SerialWorker {
  public:
   explicit HostsReader(DnsConfigServicePosix* service)
       :  service_(service), path_(kFilePathHosts), success_(false) {}
 
  private:
-  virtual ~HostsReader() {}
+  ~HostsReader() override {}
 
-  virtual void DoWork() override {
+  void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     success_ = ParseHostsFile(path_, &hosts_);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.HostsParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() override {
+  void OnWorkFinished() override {
     if (success_) {
       service_->OnHostsRead(hosts_);
     } else {
       LOG(WARNING) << "Failed to read DnsHosts.";
     }
   }
 
   DnsConfigServicePosix* service_;
   const base::FilePath path_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
@@ skipping 154 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net