replace OVERRIDE and FINAL with override and 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 OnError(QuicFramer* framer) override {}
+  virtual void OnPacket() override {}
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {}
+      const QuicPublicResetPacket& packet) override {}
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {}
-  virtual void OnRevivedPacket() OVERRIDE {}
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
-  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
+      const QuicVersionNegotiationPacket& packet) override {}
+  virtual void OnRevivedPacket() override {}
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override;
+  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   virtual 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;
+      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(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
+      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;
+      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 {}
+      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 {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 };
 
 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
   MockConnectionVisitor();
   virtual ~MockConnectionVisitor();
 
@@ skipping 16 matching lines @@
   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;
+  virtual const QuicClock* GetClock() const override;
+  virtual QuicRandom* GetRandomGenerator() override;
+  virtual 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 34 matching lines @@
   MOCK_METHOD2(SendWindowUpdate, void(QuicStreamId id,
                                       QuicStreamOffset byte_offset));
   MOCK_METHOD0(OnCanWrite, void());
 
   void ProcessUdpPacketInternal(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet) {
     QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
   }
 
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
     return false;
   }
 
  private:
   scoped_ptr<QuicConnectionHelperInterface> helper_;
 
   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();
 
-  virtual void SendOrQueuePacket(QueuedPacket packet) OVERRIDE;
+  virtual 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 31 matching lines @@
 class TestSession : public QuicSession {
  public:
   TestSession(QuicConnection* connection, const QuicConfig& config);
   virtual ~TestSession();
 
   MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id));
   MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*());
 
   void SetCryptoStream(QuicCryptoStream* stream);
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+  virtual QuicCryptoStream* GetCryptoStream() override;
 
  private:
   QuicCryptoStream* crypto_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSession);
 };
 
 class TestClientSession : public QuicClientSessionBase {
  public:
   TestClientSession(QuicConnection* connection, const QuicConfig& config);
   virtual ~TestClientSession();
 
   // QuicClientSessionBase
   MOCK_METHOD1(OnProofValid,
                void(const QuicCryptoClientConfig::CachedState& cached));
   MOCK_METHOD1(OnProofVerifyDetailsAvailable,
                void(const ProofVerifyDetails& verify_details));
 
   // TestClientSession
   MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id));
   MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*());
 
   void SetCryptoStream(QuicCryptoStream* stream);
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+  virtual QuicCryptoStream* GetCryptoStream() override;
 
  private:
   QuicCryptoStream* crypto_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestClientSession);
 };
 
 class MockPacketWriter : public QuicPacketWriter {
  public:
   MockPacketWriter();
@@ skipping 67 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockLossAlgorithm);
 };
 
 class TestEntropyCalculator :
       public QuicReceivedEntropyHashCalculatorInterface {
  public:
   TestEntropyCalculator();
   virtual ~TestEntropyCalculator();
 
   virtual QuicPacketEntropyHash EntropyHash(
-      QuicPacketSequenceNumber sequence_number) const OVERRIDE;
+      QuicPacketSequenceNumber sequence_number) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestEntropyCalculator);
 };
 
 class MockEntropyCalculator : public TestEntropyCalculator {
  public:
   MockEntropyCalculator();
   virtual ~MockEntropyCalculator();
 
@@ skipping 37 matching lines @@
 
 // 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();
 
   virtual QuicPacketWriter* Create(QuicServerPacketWriter* writer,
-                                   QuicConnection* connection) OVERRIDE;
+                                   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();
 
     virtual WriteResult WritePacket(
         const char* buffer,
         size_t buf_len,
         const IPAddressNumber& self_address,
-        const IPEndPoint& peer_address) OVERRIDE;
+        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_