Standardize usage of virtual/override/final in net/

net/spdy/spdy_websocket_stream_unittest.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/spdy/spdy_websocket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
   EventType event_type;
   SpdyHeaderBlock headers;
   int result;
   std::string data;
 };
 
 class SpdyWebSocketStreamEventRecorder : public SpdyWebSocketStream::Delegate {
  public:
   explicit SpdyWebSocketStreamEventRecorder(const CompletionCallback& callback)
       : callback_(callback) {}
-  virtual ~SpdyWebSocketStreamEventRecorder() {}
+  ~SpdyWebSocketStreamEventRecorder() override {}
 
   typedef base::Callback<void(SpdyWebSocketStreamEvent*)> StreamEventCallback;
 
   void SetOnCreated(const StreamEventCallback& callback) {
     on_created_ = callback;
   }
   void SetOnSentHeaders(const StreamEventCallback& callback) {
     on_sent_headers_ = callback;
   }
   void SetOnReceivedHeader(const StreamEventCallback& callback) {
     on_received_header_ = callback;
   }
   void SetOnSentData(const StreamEventCallback& callback) {
     on_sent_data_ = callback;
   }
   void SetOnReceivedData(const StreamEventCallback& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const StreamEventCallback& callback) {
     on_close_ = callback;
   }
 
-  virtual void OnCreatedSpdyStream(int result) override {
+  void OnCreatedSpdyStream(int result) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
                                  SpdyHeaderBlock(),
                                  result,
                                  std::string()));
     if (!on_created_.is_null())
       on_created_.Run(&events_.back());
   }
-  virtual void OnSentSpdyHeaders() override {
+  void OnSentSpdyHeaders() override {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
                                  SpdyHeaderBlock(),
                                  OK,
                                  std::string()));
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnSpdyResponseHeadersUpdated(
+  void OnSpdyResponseHeadersUpdated(
       const SpdyHeaderBlock& response_headers) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
             response_headers,
             OK,
             std::string()));
     if (!on_received_header_.is_null())
       on_received_header_.Run(&events_.back());
   }
-  virtual void OnSentSpdyData(size_t bytes_sent) override {
+  void OnSentSpdyData(size_t bytes_sent) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
             SpdyHeaderBlock(),
             static_cast<int>(bytes_sent),
             std::string()));
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override {
+  void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override {
     std::string buffer_data;
     size_t buffer_len = 0;
     if (buffer) {
       buffer_len = buffer->GetRemainingSize();
       buffer_data.append(buffer->GetRemainingData(), buffer_len);
     }
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_DATA,
             SpdyHeaderBlock(),
             buffer_len,
             buffer_data));
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnCloseSpdyStream() override {
+  void OnCloseSpdyStream() override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_CLOSE,
             SpdyHeaderBlock(),
             OK,
             std::string()));
     if (!on_close_.is_null())
       on_close_.Run(&events_.back());
     if (!callback_.is_null())
       callback_.Run(OK);
@@ skipping 519 matching lines @@
   EXPECT_EQ(OK, events[7].result);
 
   // EOF close SPDY session.
   EXPECT_FALSE(
       HasSpdySession(http_session_->spdy_session_pool(), spdy_session_key_));
   EXPECT_TRUE(data.at_read_eof());
   EXPECT_TRUE(data.at_write_eof());
 }
 
 }  // namespace net