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

chrome/browser/devtools/device/android_web_socket.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 "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/browser/devtools/device/android_device_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
@@ skipping 35 matching lines @@
  public:
   DelegateWrapper(base::WeakPtr<Delegate> weak_delegate,
                   scoped_refptr<base::MessageLoopProxy> message_loop)
       : weak_delegate_(weak_delegate),
         message_loop_(message_loop) {
   }
 
   virtual ~DelegateWrapper() {}
 
   // AndroidWebSocket::Delegate implementation
-  virtual void OnSocketOpened() OVERRIDE {
+  virtual void OnSocketOpened() override {
     message_loop_->PostTask(FROM_HERE,
         base::Bind(&Delegate::OnSocketOpened, weak_delegate_));
   }
 
-  virtual void OnFrameRead(const std::string& message) OVERRIDE {
+  virtual void OnFrameRead(const std::string& message) override {
     message_loop_->PostTask(FROM_HERE,
         base::Bind(&Delegate::OnFrameRead, weak_delegate_, message));
   }
 
-  virtual void OnSocketClosed() OVERRIDE {
+  virtual void OnSocketClosed() override {
     message_loop_->PostTask(FROM_HERE,
         base::Bind(&Delegate::OnSocketClosed, weak_delegate_));
   }
 
  private:
   base::WeakPtr<Delegate> weak_delegate_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 };
 
 class AndroidWebSocketImpl
     : public AndroidDeviceManager::AndroidWebSocket,
       public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
   typedef AndroidDeviceManager::Device Device;
   AndroidWebSocketImpl(
       scoped_refptr<base::MessageLoopProxy> device_message_loop,
       scoped_refptr<Device> device,
       const std::string& socket_name,
       const std::string& url,
       AndroidWebSocket::Delegate* delegate);
 
   virtual ~AndroidWebSocketImpl();
 
   // AndroidWebSocket implementation
-  virtual void SendFrame(const std::string& message) OVERRIDE;
+  virtual void SendFrame(const std::string& message) override;
 
   // AndroidWebSocket::Delegate implementation
-  virtual void OnSocketOpened() OVERRIDE;
-  virtual void OnFrameRead(const std::string& message) OVERRIDE;
-  virtual void OnSocketClosed() OVERRIDE;
+  virtual void OnSocketOpened() override;
+  virtual void OnFrameRead(const std::string& message) override;
+  virtual void OnSocketClosed() override;
 
  private:
   void Connected(int result, scoped_ptr<net::StreamSocket> socket);
 
   scoped_refptr<base::MessageLoopProxy> device_message_loop_;
   scoped_refptr<Device> device_;
   std::string socket_name_;
   std::string url_;
   WebSocketImpl* connection_;
   DelegateWrapper* delegate_wrapper_;
@@ skipping 164 matching lines @@
 }  // namespace
 
 AndroidDeviceManager::AndroidWebSocket*
 AndroidDeviceManager::Device::CreateWebSocket(
     const std::string& socket,
     const std::string& url,
     AndroidDeviceManager::AndroidWebSocket::Delegate* delegate) {
   return new AndroidWebSocketImpl(
       device_message_loop_, this, socket, url, delegate);
 }