Standardize usage of virtual/override/final specifiers.

chrome/common/local_discovery/service_discovery_client_impl.h

 // Copyright 2014 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.
 
 #ifndef CHROME_COMMON_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_
 #define CHROME_COMMON_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/common/local_discovery/service_discovery_client.h"
 #include "net/dns/mdns_client.h"
 
 namespace local_discovery {
 
 class ServiceDiscoveryClientImpl : public ServiceDiscoveryClient {
  public:
   // |mdns_client| must outlive the Service Discovery Client.
   explicit ServiceDiscoveryClientImpl(net::MDnsClient* mdns_client);
-  virtual ~ServiceDiscoveryClientImpl();
+  ~ServiceDiscoveryClientImpl() override;
 
   // ServiceDiscoveryClient implementation:
-  virtual scoped_ptr<ServiceWatcher> CreateServiceWatcher(
+  scoped_ptr<ServiceWatcher> CreateServiceWatcher(
       const std::string& service_type,
       const ServiceWatcher::UpdatedCallback& callback) override;
 
-  virtual scoped_ptr<ServiceResolver> CreateServiceResolver(
+  scoped_ptr<ServiceResolver> CreateServiceResolver(
       const std::string& service_name,
       const ServiceResolver::ResolveCompleteCallback& callback) override;
 
-  virtual scoped_ptr<LocalDomainResolver> CreateLocalDomainResolver(
+  scoped_ptr<LocalDomainResolver> CreateLocalDomainResolver(
       const std::string& domain,
       net::AddressFamily address_family,
       const LocalDomainResolver::IPAddressCallback& callback) override;
 
  private:
   net::MDnsClient* mdns_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceDiscoveryClientImpl);
 };
 
 class ServiceWatcherImpl : public ServiceWatcher,
                            public net::MDnsListener::Delegate,
                            public base::SupportsWeakPtr<ServiceWatcherImpl> {
  public:
   ServiceWatcherImpl(const std::string& service_type,
                      const ServiceWatcher::UpdatedCallback& callback,
                      net::MDnsClient* mdns_client);
   // Listening will automatically stop when the destructor is called.
-  virtual ~ServiceWatcherImpl();
+  ~ServiceWatcherImpl() override;
 
   // ServiceWatcher implementation:
-  virtual void Start() override;
+  void Start() override;
 
-  virtual void DiscoverNewServices(bool force_update) override;
+  void DiscoverNewServices(bool force_update) override;
 
-  virtual void SetActivelyRefreshServices(
-      bool actively_refresh_services) override;
+  void SetActivelyRefreshServices(bool actively_refresh_services) override;
 
-  virtual std::string GetServiceType() const override;
+  std::string GetServiceType() const override;
 
-  virtual void OnRecordUpdate(net::MDnsListener::UpdateType update,
-                              const net::RecordParsed* record) override;
+  void OnRecordUpdate(net::MDnsListener::UpdateType update,
+                      const net::RecordParsed* record) override;
 
-  virtual void OnNsecRecord(const std::string& name, unsigned rrtype) override;
+  void OnNsecRecord(const std::string& name, unsigned rrtype) override;
 
-  virtual void OnCachePurged() override;
+  void OnCachePurged() override;
 
   virtual void OnTransactionResponse(
       scoped_ptr<net::MDnsTransaction>* transaction,
       net::MDnsTransaction::Result result,
       const net::RecordParsed* record);
 
  private:
   struct ServiceListeners {
     ServiceListeners(const std::string& service_name,
                      ServiceWatcherImpl* watcher,
@@ skipping 71 matching lines @@
 };
 
 class ServiceResolverImpl
     : public ServiceResolver,
       public base::SupportsWeakPtr<ServiceResolverImpl> {
  public:
   ServiceResolverImpl(const std::string& service_name,
                       const ServiceResolver::ResolveCompleteCallback& callback,
                       net::MDnsClient* mdns_client);
 
-  virtual ~ServiceResolverImpl();
+  ~ServiceResolverImpl() override;
 
   // ServiceResolver implementation:
-  virtual void StartResolving() override;
+  void StartResolving() override;
 
-  virtual std::string GetName() const override;
+  std::string GetName() const override;
 
  private:
   // Respond to transaction finishing for SRV records.
   void SrvRecordTransactionResponse(net::MDnsTransaction::Result status,
                                     const net::RecordParsed* record);
 
   // Respond to transaction finishing for TXT records.
   void TxtRecordTransactionResponse(net::MDnsTransaction::Result status,
                                     const net::RecordParsed* record);
 
@@ skipping 43 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ServiceResolverImpl);
 };
 
 class LocalDomainResolverImpl : public LocalDomainResolver {
  public:
   LocalDomainResolverImpl(const std::string& domain,
                           net::AddressFamily address_family,
                           const IPAddressCallback& callback,
                           net::MDnsClient* mdns_client);
-  virtual ~LocalDomainResolverImpl();
+  ~LocalDomainResolverImpl() override;
 
-  virtual void Start() override;
+  void Start() override;
 
   const std::string& domain() { return domain_; }
 
  private:
   void OnTransactionComplete(
       net::MDnsTransaction::Result result,
       const net::RecordParsed* record);
 
   scoped_ptr<net::MDnsTransaction> CreateTransaction(uint16 type);
 
@@ skipping 17 matching lines @@
 
   base::CancelableCallback<void()> timeout_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalDomainResolverImpl);
 };
 
 
 }  // namespace local_discovery
 
 #endif  // CHROME_COMMON_LOCAL_DISCOVERY_SERVICE_DISCOVERY_CLIENT_IMPL_H_