replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/android/dev_tools_server.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 "chrome/browser/android/dev_tools_server.h"
 
 #include <pwd.h>
 #include <cstring>
 
 #include "base/android/jni_string.h"
@@ skipping 68 matching lines @@
 // Delegate implementation for the devtools http handler on android. A new
 // instance of this gets created each time devtools is enabled.
 class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
  public:
   explicit DevToolsServerDelegate(
       const net::UnixDomainServerSocket::AuthCallback& auth_callback)
       : last_tethering_socket_(0),
         auth_callback_(auth_callback) {
   }
 
-  virtual std::string GetDiscoveryPageHTML() OVERRIDE {
+  virtual std::string GetDiscoveryPageHTML() override {
     // TopSites updates itself after a delay. Ask TopSites to update itself
     // when we're about to show the remote debugging landing page.
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DevToolsServerDelegate::PopulatePageThumbnails));
     return ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_DEVTOOLS_DISCOVERY_PAGE_HTML).as_string();
   }
 
-  virtual bool BundlesFrontendResources() OVERRIDE {
+  virtual bool BundlesFrontendResources() override {
     return false;
   }
 
-  virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
+  virtual base::FilePath GetDebugFrontendDir() override {
     return base::FilePath();
   }
 
   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
       net::StreamListenSocket::Delegate* delegate,
-      std::string* name) OVERRIDE {
+      std::string* name) override {
     *name = base::StringPrintf(
         kTetheringSocketName, getpid(), ++last_tethering_socket_);
     return net::deprecated::UnixDomainListenSocket::
         CreateAndListenWithAbstractNamespace(
             *name,
             "",
             delegate,
             auth_callback_)
         .PassAs<net::StreamListenSocket>();
   }
@@ skipping 20 matching lines @@
  public:
   UnixDomainServerSocketFactory(
       const std::string& socket_name,
       const net::UnixDomainServerSocket::AuthCallback& auth_callback)
       : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1),
         auth_callback_(auth_callback) {
   }
 
  private:
   // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
+  virtual scoped_ptr<net::ServerSocket> Create() const override {
     return scoped_ptr<net::ServerSocket>(
         new net::UnixDomainServerSocket(auth_callback_,
                                         true /* use_abstract_namespace */));
   }
 
-  virtual scoped_ptr<net::ServerSocket> CreateAndListen() const OVERRIDE {
+  virtual scoped_ptr<net::ServerSocket> CreateAndListen() const override {
     scoped_ptr<net::ServerSocket> socket = Create();
     if (!socket)
       return scoped_ptr<net::ServerSocket>();
 
     if (socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK)
       return socket.Pass();
 
     // Try a fallback socket name.
     const std::string fallback_address(
         base::StringPrintf("%s_%d", address_.c_str(), getpid()));
@@ skipping 84 matching lines @@
                                       jlong server,
                                       jboolean enabled,
                                       jboolean allow_debug_permission) {
   DevToolsServer* devtools_server = reinterpret_cast<DevToolsServer*>(server);
   if (enabled) {
     devtools_server->Start(allow_debug_permission);
   } else {
     devtools_server->Stop();
   }
 }