replace OVERRIDE and FINAL with override and final in net/

net/dns/mdns_client_unittest.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 <queue>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 373 matching lines @@
 
  private:
   bool set_;
   std::string name_;
   std::string ptrdomain_;
   int ttl_;
 };
 
 class MDnsTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
   void DeleteTransaction();
   void DeleteBothListeners();
   void RunFor(base::TimeDelta time_period);
   void Stop();
 
   MOCK_METHOD2(MockableRecordCallback, void(MDnsTransaction::Result result,
                                             const RecordParsed* record));
 
   MOCK_METHOD2(MockableRecordCallback2, void(MDnsTransaction::Result result,
                                              const RecordParsed* record));
@@ skipping 645 matching lines @@
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _));
 
   RunFor(base::TimeDelta::FromSeconds(6));
 }
 
 // Note: These tests assume that the ipv4 socket will always be created first.
 // This is a simplifying assumption based on the way the code works now.
 class SimpleMockSocketFactory : public MDnsSocketFactory {
  public:
   virtual void CreateSockets(
-      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE {
+      ScopedVector<DatagramServerSocket>* sockets) override {
     sockets->clear();
     sockets->swap(sockets_);
   }
 
   void PushSocket(DatagramServerSocket* socket) {
     sockets_.push_back(socket);
   }
 
  private:
   ScopedVector<DatagramServerSocket> sockets_;
@@ skipping 10 matching lines @@
   MOCK_METHOD1(OnConnectionError, void(int error));
 };
 
 class MDnsConnectionTest : public ::testing::Test {
  public:
   MDnsConnectionTest() : connection_(&delegate_) {
   }
 
  protected:
   // Follow successful connection initialization.
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     socket_ipv4_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV4);
     socket_ipv6_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV6);
     factory_.PushSocket(socket_ipv6_);
     factory_.PushSocket(socket_ipv4_);
     sample_packet_ = MakeString(kSamplePacket1, sizeof(kSamplePacket1));
     sample_buffer_ = new StringIOBuffer(sample_packet_);
   }
 
   bool InitConnection() {
     return connection_.Init(&factory_);
@@ skipping 51 matching lines @@
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
   callback.Run(ERR_SOCKET_NOT_CONNECTED);
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 class MDnsConnectionSendTest : public MDnsConnectionTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     MDnsConnectionTest::SetUp();
     EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
         .WillOnce(Return(ERR_IO_PENDING));
     EXPECT_TRUE(InitConnection());
   }
 };
 
 TEST_F(MDnsConnectionSendTest, Send) {
@@ skipping 42 matching lines @@
   // Expect call for the second IPv6 packed.
   EXPECT_CALL(*socket_ipv6_,
               SendToInternal(sample_packet_, "[ff02::fb]:5353", _))
       .WillOnce(Return(OK));
   callback.Run(OK);
 }
 
 }  // namespace
 
 }  // namespace net