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

chrome/browser/local_discovery/service_discovery_client_mdns.cc

 // 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.
 
 #include "chrome/browser/local_discovery/service_discovery_client_mdns.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 94 matching lines @@
 
 typedef base::Callback<void(bool)> MdnsInitCallback;
 
 class SocketFactory : public net::MDnsSocketFactory {
  public:
   explicit SocketFactory(const net::InterfaceIndexFamilyList& interfaces)
       : interfaces_(interfaces) {}
 
   // net::MDnsSocketFactory implementation:
   virtual void CreateSockets(
-      ScopedVector<net::DatagramServerSocket>* sockets) OVERRIDE {
+      ScopedVector<net::DatagramServerSocket>* sockets) override {
     for (size_t i = 0; i < interfaces_.size(); ++i) {
       DCHECK(interfaces_[i].second == net::ADDRESS_FAMILY_IPV4 ||
              interfaces_[i].second == net::ADDRESS_FAMILY_IPV6);
       scoped_ptr<net::DatagramServerSocket> socket(
           CreateAndBindMDnsSocket(interfaces_[i].second, interfaces_[i].first));
       if (socket)
         sockets->push_back(socket.release());
     }
   }
 
@@ skipping 16 matching lines @@
   typedef ProxyBase<T> Base;
 
   explicit ProxyBase(ServiceDiscoveryClientMdns* client)
       : Proxy(client) {
   }
 
   virtual ~ProxyBase() {
     DeleteOnMdnsThread(implementation_.release());
   }
 
-  virtual bool IsValid() OVERRIDE {
+  virtual bool IsValid() override {
     return !!implementation();
   }
 
-  virtual void OnMdnsDestroy() OVERRIDE {
+  virtual void OnMdnsDestroy() override {
     DeleteOnMdnsThread(implementation_.release());
   };
 
  protected:
   void set_implementation(scoped_ptr<T> implementation) {
     implementation_ = implementation.Pass();
   }
 
   T* implementation()  const {
     return implementation_.get();
@@ skipping 13 matching lines @@
         service_type_(service_type),
         callback_(callback) {
     // It's safe to call |CreateServiceWatcher| on UI thread, because
     // |MDnsClient| is not used there. It's simplify implementation.
     set_implementation(client()->CreateServiceWatcher(
         service_type,
         base::Bind(&ServiceWatcherProxy::OnCallback, GetWeakPtr(), callback)));
   }
 
   // ServiceWatcher methods.
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     if (implementation()) {
       PostToMdnsThread(base::Bind(&ServiceWatcher::Start,
                                   base::Unretained(implementation())));
     }
   }
 
-  virtual void DiscoverNewServices(bool force_update) OVERRIDE {
+  virtual void DiscoverNewServices(bool force_update) override {
     if (implementation()) {
       PostToMdnsThread(base::Bind(&ServiceWatcher::DiscoverNewServices,
                                   base::Unretained(implementation()),
                                   force_update));
     }
   }
 
   virtual void SetActivelyRefreshServices(
-      bool actively_refresh_services) OVERRIDE {
+      bool actively_refresh_services) override {
     if (implementation()) {
       PostToMdnsThread(base::Bind(&ServiceWatcher::SetActivelyRefreshServices,
                                   base::Unretained(implementation()),
                                   actively_refresh_services));
     }
   }
 
-  virtual std::string GetServiceType() const OVERRIDE {
+  virtual std::string GetServiceType() const override {
     return service_type_;
   }
 
-  virtual void OnNewMdnsReady() OVERRIDE {
+  virtual void OnNewMdnsReady() override {
     ProxyBase<ServiceWatcher>::OnNewMdnsReady();
     if (!implementation())
       callback_.Run(ServiceWatcher::UPDATE_INVALIDATED, "");
   }
 
  private:
   static void OnCallback(const WeakPtr& proxy,
                          const ServiceWatcher::UpdatedCallback& callback,
                          UpdateType a1,
                          const std::string& a2) {
@@ skipping 14 matching lines @@
       : ProxyBase(client_mdns),
         service_name_(service_name) {
     // It's safe to call |CreateServiceResolver| on UI thread, because
     // |MDnsClient| is not used there. It's simplify implementation.
     set_implementation(client()->CreateServiceResolver(
         service_name,
         base::Bind(&ServiceResolverProxy::OnCallback, GetWeakPtr(), callback)));
   }
 
   // ServiceResolver methods.
-  virtual void StartResolving() OVERRIDE {
+  virtual void StartResolving() override {
     if (implementation()) {
       PostToMdnsThread(base::Bind(&ServiceResolver::StartResolving,
                                   base::Unretained(implementation())));
     }
   };
 
-  virtual std::string GetName() const OVERRIDE {
+  virtual std::string GetName() const override {
     return service_name_;
   }
 
  private:
   static void OnCallback(
       const WeakPtr& proxy,
       const ServiceResolver::ResolveCompleteCallback& callback,
       RequestStatus a1,
       const ServiceDescription& a2) {
     DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 16 matching lines @@
     // It's safe to call |CreateLocalDomainResolver| on UI thread, because
     // |MDnsClient| is not used there. It's simplify implementation.
     set_implementation(client()->CreateLocalDomainResolver(
         domain,
         address_family,
         base::Bind(
             &LocalDomainResolverProxy::OnCallback, GetWeakPtr(), callback)));
   }
 
   // LocalDomainResolver methods.
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     if (implementation()) {
       PostToMdnsThread(base::Bind(&LocalDomainResolver::Start,
                                   base::Unretained(implementation())));
     }
   };
 
  private:
   static void OnCallback(const WeakPtr& proxy,
                          const LocalDomainResolver::IPAddressCallback& callback,
                          bool a1,
@@ skipping 129 matching lines @@
   OnBeforeMdnsDestroy();
   // After calling |Proxy::OnMdnsDestroy| all references to client_ and mdns_
   // should be destroyed.
   if (client_)
     mdns_runner_->DeleteSoon(FROM_HERE, client_.release());
   if (mdns_)
     mdns_runner_->DeleteSoon(FROM_HERE, mdns_.release());
 }
 
 }  // namespace local_discovery