replace OVERRIDE and FINAL with override and final in net/

net/tools/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_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <string>
@@ skipping 86 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 MockPacketWriter : public QuicPacketWriter {
  public:
   MockPacketWriter();
@@ skipping 44 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(QuicPacketWriter* 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,
                               QuicPacketWriter* 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 tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_