replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/local_discovery/service_discovery_host_client.cc

 // Copyright 2013 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 "chrome/browser/local_discovery/service_discovery_host_client.h"
 
 #include "chrome/common/local_discovery/local_discovery_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 #include "net/dns/mdns_client.h"
@@ skipping 51 matching lines @@
         started_(false) {
   }
 
   virtual ~ServiceWatcherProxy() {
     DVLOG(1) << "~ServiceWatcherProxy with id " << id_;
     host_->UnregisterWatcherCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyWatcher(id_));
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DVLOG(1) << "ServiceWatcher::Start with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_StartWatcher(id_, service_type_));
     started_ = true;
   }
 
-  virtual void DiscoverNewServices(bool force_update) OVERRIDE {
+  virtual void DiscoverNewServices(bool force_update) override {
     DVLOG(1) << "ServiceWatcher::DiscoverNewServices with id " << id_;
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_DiscoverServices(id_, force_update));
   }
 
   virtual void SetActivelyRefreshServices(
-      bool actively_refresh_services) OVERRIDE {
+      bool actively_refresh_services) override {
     DVLOG(1) << "ServiceWatcher::SetActivelyRefreshServices with id " << id_;
     DCHECK(started_);
     host_->Send(new LocalDiscoveryMsg_SetActivelyRefreshServices(
         id_, actively_refresh_services));
   }
 
-  virtual std::string GetServiceType() const OVERRIDE {
+  virtual std::string GetServiceType() const override {
     return service_type_;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_type_;
   const uint64 id_;
   bool started_;
 };
 
 class ServiceDiscoveryHostClient::ServiceResolverProxy
     : public ServiceResolver {
  public:
   ServiceResolverProxy(ServiceDiscoveryHostClient* host,
                        const std::string& service_name,
                        const ServiceResolver::ResolveCompleteCallback& callback)
       : host_(host),
         service_name_(service_name),
         id_(host->RegisterResolverCallback(callback)),
         started_(false) {
   }
 
   virtual ~ServiceResolverProxy() {
     DVLOG(1) << "~ServiceResolverProxy with id " << id_;
     host_->UnregisterResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyResolver(id_));
   }
 
-  virtual void StartResolving() OVERRIDE {
+  virtual void StartResolving() override {
     DVLOG(1) << "ServiceResolverProxy::StartResolving with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveService(id_, service_name_));
     started_ = true;
   }
 
-  virtual std::string GetName() const OVERRIDE {
+  virtual std::string GetName() const override {
     return service_name_;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   const std::string service_name_;
   const uint64 id_;
   bool started_;
 };
 
@@ skipping 11 matching lines @@
         started_(false) {
   }
 
   virtual ~LocalDomainResolverProxy() {
     DVLOG(1) << "~LocalDomainResolverProxy with id " << id_;
     host_->UnregisterLocalDomainResolverCallback(id_);
     if (started_)
       host_->Send(new LocalDiscoveryMsg_DestroyLocalDomainResolver(id_));
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DVLOG(1) << "LocalDomainResolverProxy::Start with id " << id_;
     DCHECK(!started_);
     host_->Send(new LocalDiscoveryMsg_ResolveLocalDomain(id_, domain_,
                                                          address_family_));
     started_ = true;
   }
 
  private:
   scoped_refptr<ServiceDiscoveryHostClient> host_;
   std::string domain_;
@@ skipping 273 matching lines @@
     bool success,
     const net::IPAddressNumber& ip_address_ipv4,
     const net::IPAddressNumber& ip_address_ipv6) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DomainResolverCallbacks::iterator it = domain_resolver_callbacks_.find(id);
   if (it != domain_resolver_callbacks_.end() && !it->second.is_null())
     it->second.Run(success, ip_address_ipv4, ip_address_ipv6);
 }
 
 }  // namespace local_discovery