replace OVERRIDE and FINAL with override and final in net/

net/websockets/websocket_job_test.cc

Index: net/websockets/websocket_job_test.cc
diff --git a/net/websockets/websocket_job_test.cc b/net/websockets/websocket_job_test.cc
index 59d529ae13fb513b2c0fba086c37c10fb8c6fa63..9cf3144aa69d082732db22f1cc560d980c8cc194 100644
--- a/net/websockets/websocket_job_test.cc
+++ b/net/websockets/websocket_job_test.cc
@@ -45,18 +45,18 @@ class MockSocketStream : public SocketStream {
                    URLRequestContext* context, CookieStore* cookie_store)
       : SocketStream(url, delegate, context, cookie_store) {}
 
-  virtual void Connect() OVERRIDE {}
-  virtual bool SendData(const char* data, int len) OVERRIDE {
+  virtual void Connect() override {}
+  virtual bool SendData(const char* data, int len) override {
     sent_data_ += std::string(data, len);
     return true;
   }
 
-  virtual void Close() OVERRIDE {}
+  virtual void Close() override {}
   virtual void RestartWithAuth(
-      const AuthCredentials& credentials) OVERRIDE {
+      const AuthCredentials& credentials) override {
   }
 
-  virtual void DetachDelegate() OVERRIDE {
+  virtual void DetachDelegate() override {
     delegate_ = NULL;
   }
 
@@ -98,40 +98,40 @@ class MockSocketStreamDelegate : public SocketStream::Delegate {
 
   virtual int OnStartOpenConnection(
       SocketStream* socket,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     if (!on_start_open_connection_.is_null())
       on_start_open_connection_.Run();
     return OK;
   }
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     if (!on_connected_.is_null())
       on_connected_.Run();
   }
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {
+                          int amount_sent) override {
     amount_sent_ += amount_sent;
     if (!on_sent_data_.is_null())
       on_sent_data_.Run();
   }
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {
+                              const char* data, int len) override {
     received_data_ += std::string(data, len);
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(SocketStream* socket) OVERRIDE {
+  virtual void OnClose(SocketStream* socket) override {
     if (!on_close_.is_null())
       on_close_.Run();
   }
   virtual bool CanGetCookies(SocketStream* socket,
-                             const GURL& url) OVERRIDE {
+                             const GURL& url) override {
     return allow_all_cookies_;
   }
   virtual bool CanSetCookie(SocketStream* request,
                             const GURL& url,
                             const std::string& cookie_line,
-                            CookieOptions* options) OVERRIDE {
+                            CookieOptions* options) override {
     return allow_all_cookies_;
   }
 
@@ -190,7 +190,7 @@ class MockCookieStore : public CookieStore {
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const SetCookiesCallback& callback) OVERRIDE {
+      const SetCookiesCallback& callback) override {
     bool result = SetCookieWithOptions(url, cookie_line, options);
     if (!callback.is_null())
       callback.Run(result);
@@ -199,27 +199,27 @@ class MockCookieStore : public CookieStore {
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
-      const GetCookiesCallback& callback) OVERRIDE {
+      const GetCookiesCallback& callback) override {
     if (!callback.is_null())
       callback.Run(GetCookiesWithOptions(url, options));
   }
 
   virtual void GetAllCookiesForURLAsync(
       const GURL& url,
-      const GetCookieListCallback& callback) OVERRIDE {
+      const GetCookieListCallback& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteCookieAsync(const GURL& url,
                                  const std::string& cookie_name,
-                                 const base::Closure& callback) OVERRIDE {
+                                 const base::Closure& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteAllCreatedBetweenAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
@@ -227,15 +227,15 @@ class MockCookieStore : public CookieStore {
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE {
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override {
     ADD_FAILURE();
   }
 
-  virtual CookieMonster* GetCookieMonster() OVERRIDE { return NULL; }
+  virtual CookieMonster* GetCookieMonster() override { return NULL; }
 
   const std::vector<Entry>& entries() const { return entries_; }
 
@@ -248,7 +248,7 @@ class MockCookieStore : public CookieStore {
 
 class MockSSLConfigService : public SSLConfigService {
  public:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {}
+  virtual void GetSSLConfig(SSLConfig* config) override {}
 
  protected:
   virtual ~MockSSLConfigService() {}
@@ -298,17 +298,17 @@ class MockHttpTransactionFactory : public HttpTransactionFactory {
 
   virtual int CreateTransaction(
       RequestPriority priority,
-      scoped_ptr<HttpTransaction>* trans) OVERRIDE {
+      scoped_ptr<HttpTransaction>* trans) override {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  virtual HttpCache* GetCache() OVERRIDE {
+  virtual HttpCache* GetCache() override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual HttpNetworkSession* GetSession() OVERRIDE {
+  virtual HttpNetworkSession* GetSession() override {
     return http_session_.get();
   }
 
@@ -350,34 +350,34 @@ class DeletingSocketStreamDelegate : public SocketStream::Delegate {
   // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost
 
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
     DeleteJobMaybe();
   }
 
   virtual void OnReceivedData(SocketStream* socket,
                               const char* data,
-                              int len) OVERRIDE {
+                              int len) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnClose(SocketStream* socket) OVERRIDE { DeleteJobMaybe(); }
+  virtual void OnClose(SocketStream* socket) override { DeleteJobMaybe(); }
 
   virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) OVERRIDE {
+                              AuthChallengeInfo* auth_info) override {
     DeleteJobMaybe();
   }
 
   virtual void OnSSLCertificateError(SocketStream* socket,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE {
+                                     bool fatal) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
+  virtual void OnError(const SocketStream* socket, int error) override {
     DeleteJobMaybe();
   }
 
@@ -398,12 +398,12 @@ class WebSocketJobTest : public PlatformTest,
       : spdy_util_(GetParam()),
         enable_websocket_over_spdy_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_.reset(new MockURLRequestContext(cookie_store_.get()));
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     cookie_store_ = NULL;
     context_.reset();
     websocket_ = NULL;