Standardize usage of virtual/override/final specifiers.

net/tools/quic/quic_dispatcher_test.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/tools/quic/quic_dispatcher.h"
 
 #include <string>
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
@@ skipping 89 matching lines @@
  public:
   QuicDispatcherTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance()),
         dispatcher_(config_, crypto_config_, &eps_),
         session1_(nullptr),
         session2_(nullptr) {
     dispatcher_.Initialize(1);
   }
 
-  virtual ~QuicDispatcherTest() {}
+  ~QuicDispatcherTest() override {}
 
   MockConnection* connection1() {
     return reinterpret_cast<MockConnection*>(session1_->connection());
   }
 
   MockConnection* connection2() {
     return reinterpret_cast<MockConnection*>(session2_->connection());
   }
 
   void ProcessPacket(IPEndPoint client_address,
@@ skipping 136 matching lines @@
   EXPECT_CALL(*time_wait_list_manager,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
   string data = "foo";
   ProcessPacket(client_address, connection_id, false, "foo");
 }
 
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}
 
-  virtual bool IsWriteBlocked() const override { return write_blocked_; }
-  virtual void SetWritable() override { write_blocked_ = false; }
+  bool IsWriteBlocked() const override { return write_blocked_; }
+  void SetWritable() override { write_blocked_ = false; }
 
-  virtual WriteResult WritePacket(
-      const char* buffer,
-      size_t buf_len,
-      const IPAddressNumber& self_client_address,
-      const IPEndPoint& peer_client_address) override {
+  WriteResult WritePacket(const char* buffer,
+                          size_t buf_len,
+                          const IPAddressNumber& self_client_address,
+                          const IPEndPoint& peer_client_address) override {
     // It would be quite possible to actually implement this method here with
     // the fake blocked status, but it would be significantly more work in
     // Chromium, and since it's not called anyway, don't bother.
     LOG(DFATAL) << "Not supported";
     return WriteResult();
   }
 
   bool write_blocked_;
 };
 
 class QuicDispatcherWriteBlockedListTest : public QuicDispatcherTest {
  public:
-  virtual void SetUp() {
+  void SetUp() override {
     writer_ = new BlockingWriter;
     QuicDispatcherPeer::SetPacketWriterFactory(&dispatcher_,
                                                new TestWriterFactory());
     QuicDispatcherPeer::UseWriter(&dispatcher_, writer_);
 
     IPEndPoint client_address(net::test::Loopback4(), 1);
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, client_address))
         .WillOnce(testing::Return(CreateSession(
                       &dispatcher_, 1, client_address, &session1_)));
     ProcessPacket(client_address, 1, true, "foo");
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, client_address))
         .WillOnce(testing::Return(CreateSession(
                       &dispatcher_, 2, client_address, &session2_)));
     ProcessPacket(client_address, 2, true, "bar");
 
     blocked_list_ = QuicDispatcherPeer::GetWriteBlockedList(&dispatcher_);
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     EXPECT_CALL(*connection1(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     EXPECT_CALL(*connection2(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     dispatcher_.Shutdown();
   }
 
   void SetBlocked() {
     writer_->write_blocked_ = true;
   }
 
   void BlockConnection2() {
@@ skipping 133 matching lines @@
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net