Standardize usage of virtual/override/final in net/

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <string>
@@ skipping 172 matching lines @@
   MOCK_METHOD0(OnPacketComplete, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFramerVisitor);
 };
 
 class NoOpFramerVisitor : public QuicFramerVisitorInterface {
  public:
   NoOpFramerVisitor() {}
 
-  virtual void OnError(QuicFramer* framer) override {}
-  virtual void OnPacket() override {}
-  virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) override {}
-  virtual void OnVersionNegotiationPacket(
+  void OnError(QuicFramer* framer) override {}
+  void OnPacket() override {}
+  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {}
+  void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override {}
-  virtual void OnRevivedPacket() override {}
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) override;
-  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
-  virtual bool OnUnauthenticatedPublicHeader(
+  void OnRevivedPacket() override {}
+  bool OnProtocolVersionMismatch(QuicVersion version) override;
+  bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
+  bool OnUnauthenticatedPublicHeader(
       const QuicPacketPublicHeader& header) override;
-  virtual void OnDecryptedPacket(EncryptionLevel level) override {}
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) override;
-  virtual void OnFecProtectedPayload(base::StringPiece payload) override {}
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override;
-  virtual bool OnAckFrame(const QuicAckFrame& frame) override;
-  virtual bool OnCongestionFeedbackFrame(
+  void OnDecryptedPacket(EncryptionLevel level) override {}
+  bool OnPacketHeader(const QuicPacketHeader& header) override;
+  void OnFecProtectedPayload(base::StringPiece payload) override {}
+  bool OnStreamFrame(const QuicStreamFrame& frame) override;
+  bool OnAckFrame(const QuicAckFrame& frame) override;
+  bool OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) override;
-  virtual bool OnStopWaitingFrame(
-      const QuicStopWaitingFrame& frame) override;
-  virtual bool OnPingFrame(const QuicPingFrame& frame) override;
-  virtual void OnFecData(const QuicFecData& fec) override {}
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
-  virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) override;
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
-  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
-  virtual void OnPacketComplete() override {}
+  bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+  bool OnPingFrame(const QuicPingFrame& frame) override;
+  void OnFecData(const QuicFecData& fec) override {}
+  bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
+  bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override;
+  bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+  bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+  bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+  void OnPacketComplete() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 };
 
 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
   MockConnectionVisitor();
   virtual ~MockConnectionVisitor();
 
@@ skipping 15 matching lines @@
                void(const QuicVersion& version));
   MOCK_METHOD0(OnConfigNegotiated, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor);
 };
 
 class MockHelper : public QuicConnectionHelperInterface {
  public:
   MockHelper();
-  virtual ~MockHelper();
-  virtual const QuicClock* GetClock() const override;
-  virtual QuicRandom* GetRandomGenerator() override;
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
+  ~MockHelper() override;
+  const QuicClock* GetClock() const override;
+  QuicRandom* GetRandomGenerator() override;
+  QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
   void AdvanceTime(QuicTime::Delta delta);
 
  private:
   MockClock clock_;
   MockRandom random_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(MockHelper);
 };
 
 class MockConnection : public QuicConnection {
@@ skipping 51 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class PacketSavingConnection : public MockConnection {
  public:
   explicit PacketSavingConnection(bool is_server);
 
   PacketSavingConnection(bool is_server,
                          const QuicVersionVector& supported_versions);
 
-  virtual ~PacketSavingConnection();
+  ~PacketSavingConnection() override;
 
-  virtual void SendOrQueuePacket(QueuedPacket packet) override;
+  void SendOrQueuePacket(QueuedPacket packet) override;
 
   std::vector<QuicPacket*> packets_;
   std::vector<QuicEncryptedPacket*> encrypted_packets_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PacketSavingConnection);
 };
 
 class MockSession : public QuicSession {
  public:
@@ skipping 142 matching lines @@
   MOCK_CONST_METHOD0(GetLossTimeout, QuicTime());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockLossAlgorithm);
 };
 
 class TestEntropyCalculator :
       public QuicReceivedEntropyHashCalculatorInterface {
  public:
   TestEntropyCalculator();
-  virtual ~TestEntropyCalculator();
+  ~TestEntropyCalculator() override;
 
-  virtual QuicPacketEntropyHash EntropyHash(
+  QuicPacketEntropyHash EntropyHash(
       QuicPacketSequenceNumber sequence_number) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestEntropyCalculator);
 };
 
 class MockEntropyCalculator : public TestEntropyCalculator {
  public:
   MockEntropyCalculator();
   virtual ~MockEntropyCalculator();
@@ skipping 35 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockNetworkChangeVisitor);
 };
 
 // Creates per-connection packet writers that register themselves with the
 // TestWriterFactory on each write so that TestWriterFactory::OnPacketSent can
 // be routed to the appropriate QuicConnection.
 class TestWriterFactory : public QuicDispatcher::PacketWriterFactory {
  public:
   TestWriterFactory();
-  virtual ~TestWriterFactory();
+  ~TestWriterFactory() override;
 
-  virtual QuicPacketWriter* Create(QuicServerPacketWriter* writer,
-                                   QuicConnection* connection) override;
+  QuicPacketWriter* Create(QuicServerPacketWriter* writer,
+                           QuicConnection* connection) override;
 
   // Calls OnPacketSent on the last QuicConnection to write through one of the
   // packet writers created by this factory.
   void OnPacketSent(WriteResult result);
 
  private:
   class PerConnectionPacketWriter : public QuicPerConnectionPacketWriter {
    public:
     PerConnectionPacketWriter(TestWriterFactory* factory,
                               QuicServerPacketWriter* writer,
                               QuicConnection* connection);
-    virtual ~PerConnectionPacketWriter();
+    ~PerConnectionPacketWriter() override;
 
-    virtual WriteResult WritePacket(
-        const char* buffer,
-        size_t buf_len,
-        const IPAddressNumber& self_address,
-        const IPEndPoint& peer_address) override;
+    WriteResult WritePacket(const char* buffer,
+                            size_t buf_len,
+                            const IPAddressNumber& self_address,
+                            const IPEndPoint& peer_address) override;
 
    private:
     TestWriterFactory* factory_;
   };
 
   // If an asynchronous write is happening and |writer| gets deleted, this
   // clears the pointer to it to prevent use-after-free.
   void Unregister(PerConnectionPacketWriter* writer);
 
   PerConnectionPacketWriter* current_writer_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_