Standardize usage of virtual/override/final in net/

net/websockets/websocket_channel_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_channel.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <iostream>
@@ skipping 174 matching lines @@
   MOCK_METHOD0(OnStartOpeningHandshakeCalled, void());  // NOLINT
   MOCK_METHOD0(OnFinishOpeningHandshakeCalled, void());  // NOLINT
   MOCK_METHOD4(
       OnSSLCertificateErrorCalled,
       void(SSLErrorCallbacks*, const GURL&, const SSLInfo&, bool));  // NOLINT
 };
 
 // This fake EventInterface is for tests which need a WebSocketEventInterface
 // implementation but are not verifying how it is used.
 class FakeWebSocketEventInterface : public WebSocketEventInterface {
-  virtual ChannelState OnAddChannelResponse(
-      bool fail,
-      const std::string& selected_protocol,
-      const std::string& extensions) override {
+  ChannelState OnAddChannelResponse(bool fail,
+                                    const std::string& selected_protocol,
+                                    const std::string& extensions) override {
     return fail ? CHANNEL_DELETED : CHANNEL_ALIVE;
   }
-  virtual ChannelState OnDataFrame(bool fin,
-                                   WebSocketMessageType type,
-                                   const std::vector<char>& data) override {
+  ChannelState OnDataFrame(bool fin,
+                           WebSocketMessageType type,
+                           const std::vector<char>& data) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnFlowControl(int64 quota) override {
-    return CHANNEL_ALIVE;
-  }
-  virtual ChannelState OnClosingHandshake() override { return CHANNEL_ALIVE; }
-  virtual ChannelState OnFailChannel(const std::string& message) override {
+  ChannelState OnFlowControl(int64 quota) override { return CHANNEL_ALIVE; }
+  ChannelState OnClosingHandshake() override { return CHANNEL_ALIVE; }
+  ChannelState OnFailChannel(const std::string& message) override {
     return CHANNEL_DELETED;
   }
-  virtual ChannelState OnDropChannel(bool was_clean,
-                                     uint16 code,
-                                     const std::string& reason) override {
+  ChannelState OnDropChannel(bool was_clean,
+                             uint16 code,
+                             const std::string& reason) override {
     return CHANNEL_DELETED;
   }
-  virtual ChannelState OnStartOpeningHandshake(
+  ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnFinishOpeningHandshake(
+  ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnSSLCertificateError(
+  ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
       bool fatal) override {
     return CHANNEL_ALIVE;
   }
 };
 
 // This fake WebSocketStream is for tests that require a WebSocketStream but are
 // not testing the way it is used. It has minimal functionality to return
 // the |protocol| and |extensions| that it was constructed with.
 class FakeWebSocketStream : public WebSocketStream {
  public:
   // Constructs with empty protocol and extensions.
   FakeWebSocketStream() {}
 
   // Constructs with specified protocol and extensions.
   FakeWebSocketStream(const std::string& protocol,
                       const std::string& extensions)
       : protocol_(protocol), extensions_(extensions) {}
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) override {
+  int ReadFrames(ScopedVector<WebSocketFrame>* frames,
+                 const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) override {
+  int WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                  const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() override {}
+  void Close() override {}
 
   // Returns the string passed to the constructor.
-  virtual std::string GetSubProtocol() const override { return protocol_; }
+  std::string GetSubProtocol() const override { return protocol_; }
 
   // Returns the string passed to the constructor.
-  virtual std::string GetExtensions() const override { return extensions_; }
+  std::string GetExtensions() const override { return extensions_; }
 
  private:
   // The string to return from GetSubProtocol().
   std::string protocol_;
 
   // The string to return from GetExtensions().
   std::string extensions_;
 };
 
 // To make the static initialisers easier to read, we use enums rather than
@@ skipping 174 matching lines @@
 // A FakeWebSocketStream whose ReadFrames() function returns data.
 class ReadableFakeWebSocketStream : public FakeWebSocketStream {
  public:
   enum IsSync { SYNC, ASYNC };
 
   // After constructing the object, call PrepareReadFrames() once for each
   // time you wish it to return from the test.
   ReadableFakeWebSocketStream() : index_(0), read_frames_pending_(false) {}
 
   // Check that all the prepared responses have been consumed.
-  virtual ~ReadableFakeWebSocketStream() {
+  ~ReadableFakeWebSocketStream() override {
     CHECK(index_ >= responses_.size());
     CHECK(!read_frames_pending_);
   }
 
   // Prepares a fake response. Fake responses will be returned from ReadFrames()
   // in the same order they were prepared with PrepareReadFrames() and
   // PrepareReadFramesError(). If |async| is ASYNC, then ReadFrames() will
   // return ERR_IO_PENDING and the callback will be scheduled to run on the
   // message loop. This requires the test case to run the message loop. If
   // |async| is SYNC, the response will be returned synchronously. |error| is
@@ skipping 15 matching lines @@
                             ScopedVector<WebSocketFrame> frames) {
     responses_.push_back(new Response(async, error, frames.Pass()));
   }
 
   // Prepares a fake error response (ie. there is no data).
   void PrepareReadFramesError(IsSync async, int error) {
     responses_.push_back(
         new Response(async, error, ScopedVector<WebSocketFrame>()));
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) override {
+  int ReadFrames(ScopedVector<WebSocketFrame>* frames,
+                 const CompletionCallback& callback) override {
     CHECK(!read_frames_pending_);
     if (index_ >= responses_.size())
       return ERR_IO_PENDING;
     if (responses_[index_]->async == ASYNC) {
       read_frames_pending_ = true;
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&ReadableFakeWebSocketStream::DoCallback,
                      base::Unretained(this),
                      frames,
@@ skipping 35 matching lines @@
   // to "real" async responses. Once all the prepared responses have been
   // returned, ReadFrames() returns ERR_IO_PENDING but read_frames_pending_ is
   // not set to true.
   bool read_frames_pending_;
 };
 
 // A FakeWebSocketStream where writes always complete successfully and
 // synchronously.
 class WriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) override {
+  int WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                  const CompletionCallback& callback) override {
     return OK;
   }
 };
 
 // A FakeWebSocketStream where writes always fail.
 class UnWriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
-  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) override {
+  int WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                  const CompletionCallback& callback) override {
     return ERR_CONNECTION_RESET;
   }
 };
 
 // A FakeWebSocketStream which echoes any frames written back. Clears the
 // "masked" header bit, but makes no other checks for validity. Tests using this
 // must run the MessageLoop to receive the callback(s). If a message with opcode
 // Close is echoed, then an ERR_CONNECTION_CLOSED is returned in the next
 // callback. The test must do something to cause WriteFrames() to be called,
 // otherwise the ReadFrames() callback will never be called.
 class EchoeyFakeWebSocketStream : public FakeWebSocketStream {
  public:
   EchoeyFakeWebSocketStream() : read_frames_(NULL), done_(false) {}
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) override {
+  int WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                  const CompletionCallback& callback) override {
     // Users of WebSocketStream will not expect the ReadFrames() callback to be
     // called from within WriteFrames(), so post it to the message loop instead.
     stored_frames_.insert(stored_frames_.end(), frames->begin(), frames->end());
     frames->weak_clear();
     PostCallback();
     return OK;
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) override {
+  int ReadFrames(ScopedVector<WebSocketFrame>* frames,
+                 const CompletionCallback& callback) override {
     read_callback_ = callback;
     read_frames_ = frames;
     if (done_)
       PostCallback();
     return ERR_IO_PENDING;
   }
 
  private:
   void PostCallback() {
     base::MessageLoop::current()->PostTask(
@@ skipping 41 matching lines @@
 // This differs from UnWriteableFakeWebSocketStream in that it is asynchronous
 // and triggers ReadFrames to return a reset as well. Tests using this need to
 // run the message loop. There are two tricky parts here:
 // 1. Calling the write callback may call Close(), after which the read callback
 //    should not be called.
 // 2. Calling either callback may delete the stream altogether.
 class ResetOnWriteFakeWebSocketStream : public FakeWebSocketStream {
  public:
   ResetOnWriteFakeWebSocketStream() : closed_(false), weak_ptr_factory_(this) {}
 
-  virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) override {
+  int WriteFrames(ScopedVector<WebSocketFrame>* frames,
+                  const CompletionCallback& callback) override {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    ERR_CONNECTION_RESET));
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
                    weak_ptr_factory_.GetWeakPtr(),
                    read_callback_,
                    ERR_CONNECTION_RESET));
     return ERR_IO_PENDING;
   }
 
-  virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) override {
+  int ReadFrames(ScopedVector<WebSocketFrame>* frames,
+                 const CompletionCallback& callback) override {
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() override { closed_ = true; }
+  void Close() override { closed_ = true; }
 
  private:
   void CallCallbackUnlessClosed(const CompletionCallback& callback, int value) {
     if (!closed_)
       callback.Run(value);
   }
 
   CompletionCallback read_callback_;
   bool closed_;
   // An IO error can result in the socket being deleted, so we use weak pointers
@@ skipping 45 matching lines @@
 // Converts a std::string to a std::vector<char>. For test purposes, it is
 // convenient to be able to specify data as a string, but the
 // WebSocketEventInterface requires the vector<char> type.
 std::vector<char> AsVector(const std::string& s) {
   return std::vector<char>(s.begin(), s.end());
 }
 
 class FakeSSLErrorCallbacks
     : public WebSocketEventInterface::SSLErrorCallbacks {
  public:
-  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {}
-  virtual void ContinueSSLRequest() override {}
+  void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {}
+  void ContinueSSLRequest() override {}
 };
 
 // Base class for all test fixtures.
 class WebSocketChannelTest : public ::testing::Test {
  protected:
   WebSocketChannelTest() : stream_(new FakeWebSocketStream) {}
 
   // Creates a new WebSocketChannel and connects it, using the settings stored
   // in |connect_data_|.
   void CreateChannelAndConnect() {
@@ skipping 89 matching lines @@
       : deleting_(EVENT_ON_ADD_CHANNEL_RESPONSE | EVENT_ON_DATA_FRAME |
                   EVENT_ON_FLOW_CONTROL |
                   EVENT_ON_CLOSING_HANDSHAKE |
                   EVENT_ON_FAIL_CHANNEL |
                   EVENT_ON_DROP_CHANNEL |
                   EVENT_ON_START_OPENING_HANDSHAKE |
                   EVENT_ON_FINISH_OPENING_HANDSHAKE |
                   EVENT_ON_SSL_CERTIFICATE_ERROR) {}
   // Create a ChannelDeletingFakeWebSocketEventInterface. Defined out-of-line to
   // avoid circular dependency.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override;
+  scoped_ptr<WebSocketEventInterface> CreateEventInterface() override;
 
   // Tests can set deleting_ to a bitmap of EventInterfaceCall members that they
   // want to cause Channel deletion. The default is for all calls to cause
   // deletion.
   int deleting_;
 };
 
 // A FakeWebSocketEventInterface that deletes the WebSocketChannel on failure to
 // connect.
 class ChannelDeletingFakeWebSocketEventInterface
     : public FakeWebSocketEventInterface {
  public:
   ChannelDeletingFakeWebSocketEventInterface(
       WebSocketChannelDeletingTest* fixture)
       : fixture_(fixture) {}
 
-  virtual ChannelState OnAddChannelResponse(
-      bool fail,
-      const std::string& selected_protocol,
-      const std::string& extensions) override {
+  ChannelState OnAddChannelResponse(bool fail,
+                                    const std::string& selected_protocol,
+                                    const std::string& extensions) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_ADD_CHANNEL_RESPONSE);
   }
 
-  virtual ChannelState OnDataFrame(bool fin,
-                                   WebSocketMessageType type,
-                                   const std::vector<char>& data) override {
+  ChannelState OnDataFrame(bool fin,
+                           WebSocketMessageType type,
+                           const std::vector<char>& data) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DATA_FRAME);
   }
 
-  virtual ChannelState OnFlowControl(int64 quota) override {
+  ChannelState OnFlowControl(int64 quota) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FLOW_CONTROL);
   }
 
-  virtual ChannelState OnClosingHandshake() override {
+  ChannelState OnClosingHandshake() override {
     return fixture_->DeleteIfDeleting(EVENT_ON_CLOSING_HANDSHAKE);
   }
 
-  virtual ChannelState OnFailChannel(const std::string& message) override {
+  ChannelState OnFailChannel(const std::string& message) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FAIL_CHANNEL);
   }
 
-  virtual ChannelState OnDropChannel(bool was_clean,
-                                     uint16 code,
-                                     const std::string& reason) override {
+  ChannelState OnDropChannel(bool was_clean,
+                             uint16 code,
+                             const std::string& reason) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DROP_CHANNEL);
   }
 
-  virtual ChannelState OnStartOpeningHandshake(
+  ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_START_OPENING_HANDSHAKE);
   }
-  virtual ChannelState OnFinishOpeningHandshake(
+  ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FINISH_OPENING_HANDSHAKE);
   }
-  virtual ChannelState OnSSLCertificateError(
+  ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
       bool fatal) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_SSL_CERTIFICATE_ERROR);
   }
 
  private:
   // A pointer to the test fixture. Owned by the test harness; this object will
   // be deleted before it is.
@@ skipping 22 matching lines @@
   }
 
   virtual ~WebSocketChannelEventInterfaceTest() {
     DefaultValue<ChannelState>::Clear();
   }
 
   // Tests using this fixture must set expectations on the event_interface_ mock
   // object before calling CreateChannelAndConnect() or
   // CreateChannelAndConnectSuccessfully(). This will only work once per test
   // case, but once should be enough.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override {
+  scoped_ptr<WebSocketEventInterface> CreateEventInterface() override {
     return scoped_ptr<WebSocketEventInterface>(event_interface_.release());
   }
 
   scoped_ptr<MockWebSocketEventInterface> event_interface_;
 };
 
 // Base class for tests which verify that WebSocketStream methods are called
 // appropriately by using a MockWebSocketStream.
 class WebSocketChannelStreamTest : public WebSocketChannelTest {
  protected:
   WebSocketChannelStreamTest()
       : mock_stream_(new StrictMock<MockWebSocketStream>) {}
 
-  virtual void CreateChannelAndConnectSuccessfully() override {
+  void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     WebSocketChannelTest::CreateChannelAndConnectSuccessfully();
   }
 
   scoped_ptr<MockWebSocketStream> mock_stream_;
 };
 
 // Fixture for tests which test UTF-8 validation of sent Text frames via the
 // EventInterface.
 class WebSocketChannelSendUtf8Test
@@ skipping 2333 matching lines @@
   EXPECT_CALL(*mock_stream_, Close());
 
   CreateChannelAndConnectSuccessfully();
 }
 
 // Set the closing handshake timeout to a very tiny value before connecting.
 class WebSocketChannelStreamTimeoutTest : public WebSocketChannelStreamTest {
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
-  virtual void CreateChannelAndConnectSuccessfully() override {
+  void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     CreateChannelAndConnect();
     channel_->SendFlowControl(kPlentyOfQuota);
     channel_->SetClosingHandshakeTimeoutForTesting(
         TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
     connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
   }
 };
 
 // In this case the server initiates the closing handshake with a Close
@@ skipping 97 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net