Use override consistently instead of virtual.

net/tools/quic/quic_time_wait_list_manager_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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 27 matching lines @@
 using testing::Truly;
 using testing::_;
 
 namespace net {
 namespace tools {
 namespace test {
 
 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
  public:
   FramerVisitorCapturingPublicReset() {}
-  virtual ~FramerVisitorCapturingPublicReset() {}
+  virtual ~FramerVisitorCapturingPublicReset() OVERRIDE {}
 
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& public_reset) OVERRIDE {
     public_reset_packet_ = public_reset;
   }
 
   const QuicPublicResetPacket public_reset_packet() {
     return public_reset_packet_;
   }
 
@@ skipping 30 matching lines @@
 class QuicTimeWaitListManagerTest : public ::testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
       : time_wait_list_manager_(&writer_, &visitor_,
                                 &epoll_server_, QuicSupportedVersions()),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
         connection_id_(45),
         client_address_(net::test::TestPeerIPAddress(), kTestPort),
         writer_is_blocked_(false) {}
 
-  virtual ~QuicTimeWaitListManagerTest() {}
+  virtual ~QuicTimeWaitListManagerTest() OVERRIDE {}
 
-  virtual void SetUp() {
+  virtual void SetUp() OVERRIDE {
     EXPECT_CALL(writer_, IsWriteBlocked())
         .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
     EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
         .WillRepeatedly(Return(false));
   }
 
   void AddConnectionId(QuicConnectionId connection_id) {
     AddConnectionId(connection_id, QuicVersionMax(), NULL);
   }
 
@@ skipping 62 matching lines @@
 class ValidatePublicResetPacketPredicate
     : public MatcherInterface<const std::tr1::tuple<const char*, int> > {
  public:
   explicit ValidatePublicResetPacketPredicate(QuicConnectionId connection_id,
                                               QuicPacketSequenceNumber number)
       : connection_id_(connection_id), sequence_number_(number) {
   }
 
   virtual bool MatchAndExplain(
       const std::tr1::tuple<const char*, int> packet_buffer,
-      testing::MatchResultListener* /* listener */) const {
+      testing::MatchResultListener* /* listener */) const OVERRIDE {
     FramerVisitorCapturingPublicReset visitor;
     QuicFramer framer(QuicSupportedVersions(),
                       QuicTime::Zero(),
                       false);
     framer.set_visitor(&visitor);
     QuicEncryptedPacket encrypted(std::tr1::get<0>(packet_buffer),
                                   std::tr1::get<1>(packet_buffer));
     framer.ProcessPacket(encrypted);
     QuicPublicResetPacket packet = visitor.public_reset_packet();
     return connection_id_ == packet.public_header.connection_id &&
         packet.public_header.reset_flag && !packet.public_header.version_flag &&
         sequence_number_ == packet.rejected_sequence_number &&
         net::test::TestPeerIPAddress() == packet.client_address.address() &&
         kTestPort == packet.client_address.port();
   }
 
-  virtual void DescribeTo(::std::ostream* os) const { }
+  virtual void DescribeTo(::std::ostream* os) const OVERRIDE {}
 
-  virtual void DescribeNegationTo(::std::ostream* os) const { }
+  virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE {}
 
  private:
   QuicConnectionId connection_id_;
   QuicPacketSequenceNumber sequence_number_;
 };
 
 
 Matcher<const std::tr1::tuple<const char*, int> > PublicResetPacketEq(
     QuicConnectionId connection_id,
     QuicPacketSequenceNumber sequence_number) {
@@ skipping 238 matching lines @@
   EXPECT_CALL(epoll_server_, RegisterAlarm(_, _));
 
   time_wait_list_manager_.CleanUpOldConnectionIds();
   EXPECT_FALSE(IsConnectionIdInTimeWait(kConnectionId1));
   EXPECT_TRUE(IsConnectionIdInTimeWait(kConnectionId2));
 }
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net