replace OVERRIDE and FINAL with override and final in net/

net/websockets/websocket_job_test.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 "net/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 namespace net {
 
 namespace {
 
 class MockSocketStream : public SocketStream {
  public:
   MockSocketStream(const GURL& url, SocketStream::Delegate* delegate,
                    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;
   }
 
   const std::string& sent_data() const {
     return sent_data_;
   }
 
  protected:
   virtual ~MockSocketStream() {}
 
@@ skipping 21 matching lines @@
   }
   void SetOnReceivedData(const base::Closure& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const base::Closure& callback) {
     on_close_ = callback;
   }
 
   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_;
   }
 
   size_t amount_sent() const { return amount_sent_; }
   const std::string& received_data() const { return received_data_; }
 
  private:
   int amount_sent_;
   bool allow_all_cookies_;
   std::string received_data_;
@@ skipping 38 matching lines @@
       }
     }
     return result;
   }
 
   // CookieStore:
   virtual void SetCookieWithOptionsAsync(
       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);
   }
 
   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();
   }
 
   virtual void DeleteAllCreatedBetweenForHostAsync(
       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_; }
 
  private:
   friend class base::RefCountedThreadSafe<MockCookieStore>;
   virtual ~MockCookieStore() {}
 
   std::vector<Entry> entries_;
 };
 
 class MockSSLConfigService : public SSLConfigService {
  public:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {}
+  virtual void GetSSLConfig(SSLConfig* config) override {}
 
  protected:
   virtual ~MockSSLConfigService() {}
 };
 
 class MockURLRequestContext : public URLRequestContext {
  public:
   explicit MockURLRequestContext(CookieStore* cookie_store)
       : transport_security_state_() {
     set_cookie_store(cookie_store);
@@ skipping 29 matching lines @@
     host_port_pair_.set_port(80);
     spdy_session_key_ = SpdySessionKey(host_port_pair_,
                                             ProxyServer::Direct(),
                                             PRIVACY_MODE_DISABLED);
     session_ = CreateInsecureSpdySession(
         http_session_, spdy_session_key_, BoundNetLog());
   }
 
   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();
   }
 
  private:
   OrderedSocketData* data_;
   scoped_ptr<SpdySessionDependencies> session_deps_;
   scoped_refptr<HttpNetworkSession> http_session_;
   base::WeakPtr<SpdySession> session_;
   HostPortPair host_port_pair_;
   SpdySessionKey spdy_session_key_;
@@ skipping 21 matching lines @@
       job_->DetachDelegate();
       job_ = NULL;
     }
   }
 
   // SocketStream::Delegate implementation
 
   // 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();
   }
 
   // CanGetCookies() and CanSetCookies() do not appear to be able to delete the
   // WebSocketJob object.
 
  private:
   scoped_refptr<WebSocketJob> job_;
   bool delete_next_;
 };
 
 }  // namespace
 
 class WebSocketJobTest : public PlatformTest,
                          public ::testing::WithParamInterface<NextProto> {
  public:
   WebSocketJobTest()
       : 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;
     socket_ = NULL;
   }
   void DoSendRequest() {
     EXPECT_TRUE(websocket_->SendData(kHandshakeRequestWithoutCookie,
                                      kHandshakeRequestWithoutCookieLength));
   }
   void DoSendData() {
@@ skipping 868 matching lines @@
   job()->Connect();
   SetDeleteNext();
   job()->OnReceivedData(
       socket_.get(), kMinimalResponse, arraysize(kMinimalResponse) - 1);
   EXPECT_FALSE(job());
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 }  // namespace net