Standardize usage of virtual/override/final in net/

net/socket_stream/socket_stream_unittest.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 "net/socket_stream/socket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 41 matching lines @@
   int error_code;
 };
 
 class SocketStreamEventRecorder : public SocketStream::Delegate {
  public:
   // |callback| will be run when the OnClose() or OnError() method is called.
   // For OnClose(), |callback| is called with OK. For OnError(), it's called
   // with the error code.
   explicit SocketStreamEventRecorder(const CompletionCallback& callback)
       : callback_(callback) {}
-  virtual ~SocketStreamEventRecorder() {}
+  ~SocketStreamEventRecorder() override {}
 
   void SetOnStartOpenConnection(
       const base::Callback<int(SocketStreamEvent*)>& callback) {
     on_start_open_connection_ = callback;
   }
   void SetOnConnected(
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_connected_ = callback;
   }
   void SetOnSentData(
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_sent_data_ = callback;
   }
   void SetOnReceivedData(
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_close_ = callback;
   }
   void SetOnAuthRequired(
       const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_auth_required_ = callback;
   }
   void SetOnError(const base::Callback<void(SocketStreamEvent*)>& callback) {
     on_error_ = callback;
   }
 
-  virtual int OnStartOpenConnection(
-      SocketStream* socket,
-      const CompletionCallback& callback) override {
+  int OnStartOpenConnection(SocketStream* socket,
+                            const CompletionCallback& callback) override {
     connection_callback_ = callback;
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
                           socket, 0, std::string(), NULL, OK));
     if (!on_start_open_connection_.is_null())
       return on_start_open_connection_.Run(&events_.back());
     return OK;
   }
-  virtual void OnConnected(SocketStream* socket,
-                           int num_pending_send_allowed) override {
+  void OnConnected(SocketStream* socket,
+                   int num_pending_send_allowed) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_CONNECTED,
                           socket, num_pending_send_allowed, std::string(),
                           NULL, OK));
     if (!on_connected_.is_null())
       on_connected_.Run(&events_.back());
   }
-  virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) override {
+  void OnSentData(SocketStream* socket, int amount_sent) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_SENT_DATA, socket,
                           amount_sent, std::string(), NULL, OK));
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) override {
+  void OnReceivedData(SocketStream* socket,
+                      const char* data,
+                      int len) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_RECEIVED_DATA, socket, len,
                           std::string(data, len), NULL, OK));
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnClose(SocketStream* socket) override {
+  void OnClose(SocketStream* socket) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_CLOSE, socket, 0,
                           std::string(), NULL, OK));
     if (!on_close_.is_null())
       on_close_.Run(&events_.back());
     if (!callback_.is_null())
       callback_.Run(OK);
   }
-  virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) override {
+  void OnAuthRequired(SocketStream* socket,
+                      AuthChallengeInfo* auth_info) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_AUTH_REQUIRED, socket, 0,
                           std::string(), auth_info, OK));
     if (!on_auth_required_.is_null())
       on_auth_required_.Run(&events_.back());
   }
-  virtual void OnError(const SocketStream* socket, int error) override {
+  void OnError(const SocketStream* socket, int error) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_ERROR, NULL, 0,
                           std::string(), NULL, error));
     if (!on_error_.is_null())
       on_error_.Run(&events_.back());
     if (!callback_.is_null())
       callback_.Run(error);
   }
 
   void DoClose(SocketStreamEvent* event) {
@@ skipping 33 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SocketStreamEventRecorder);
 };
 
 // This is used for the test OnErrorDetachDelegate.
 class SelfDeletingDelegate : public SocketStream::Delegate {
  public:
   // |callback| must cause the test message loop to exit when called.
   explicit SelfDeletingDelegate(const CompletionCallback& callback)
       : socket_stream_(), callback_(callback) {}
 
-  virtual ~SelfDeletingDelegate() {}
+  ~SelfDeletingDelegate() override {}
 
   // Call DetachDelegate(), delete |this|, then run the callback.
-  virtual void OnError(const SocketStream* socket, int error) override {
+  void OnError(const SocketStream* socket, int error) override {
     // callback_ will be deleted when we delete |this|, so copy it to call it
     // afterwards.
     CompletionCallback callback = callback_;
     socket_stream_->DetachDelegate();
     delete this;
     callback.Run(OK);
   }
 
   // This can't be passed in the constructor because this object needs to be
   // created before SocketStream.
   void set_socket_stream(const scoped_refptr<SocketStream>& socket_stream) {
     socket_stream_ = socket_stream;
     EXPECT_EQ(socket_stream_->delegate(), this);
   }
 
-  virtual void OnConnected(SocketStream* socket, int max_pending_send_allowed)
-      override {
+  void OnConnected(SocketStream* socket,
+                   int max_pending_send_allowed) override {
     ADD_FAILURE() << "OnConnected() should not be called";
   }
-  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
+  void OnSentData(SocketStream* socket, int amount_sent) override {
     ADD_FAILURE() << "OnSentData() should not be called";
   }
-  virtual void OnReceivedData(SocketStream* socket, const char* data, int len)
-      override {
+  void OnReceivedData(SocketStream* socket,
+                      const char* data,
+                      int len) override {
     ADD_FAILURE() << "OnReceivedData() should not be called";
   }
-  virtual void OnClose(SocketStream* socket) override {
+  void OnClose(SocketStream* socket) override {
     ADD_FAILURE() << "OnClose() should not be called";
   }
 
  private:
   scoped_refptr<SocketStream> socket_stream_;
   const CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfDeletingDelegate);
 };
 
 class TestURLRequestContextWithProxy : public TestURLRequestContext {
  public:
   explicit TestURLRequestContextWithProxy(const std::string& proxy)
       : TestURLRequestContext(true) {
     context_storage_.set_proxy_service(ProxyService::CreateFixed(proxy));
     Init();
   }
-  virtual ~TestURLRequestContextWithProxy() {}
+  ~TestURLRequestContextWithProxy() override {}
 };
 
 class TestSocketStreamNetworkDelegate : public TestNetworkDelegate {
  public:
   TestSocketStreamNetworkDelegate()
       : before_connect_result_(OK) {}
-  virtual ~TestSocketStreamNetworkDelegate() {}
+  ~TestSocketStreamNetworkDelegate() override {}
 
-  virtual int OnBeforeSocketStreamConnect(
-      SocketStream* stream,
-      const CompletionCallback& callback) override {
+  int OnBeforeSocketStreamConnect(SocketStream* stream,
+                                  const CompletionCallback& callback) override {
     return before_connect_result_;
   }
 
   void SetBeforeConnectResult(int result) {
     before_connect_result_ = result;
   }
 
  private:
   int before_connect_result_;
 };
@@ skipping 767 matching lines @@
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_SENT_DATA, events[2].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_RECEIVED_DATA, events[3].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[4].event_type);
 }
 
 }  // namespace net