replace OVERRIDE and FINAL with override and final in net/

net/test/embedded_test_server/embedded_test_server_unittest.cc

 // 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.
 
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ skipping 31 matching lines @@
 
 class EmbeddedTestServerTest: public testing::Test,
                               public URLFetcherDelegate {
  public:
   EmbeddedTestServerTest()
       : num_responses_received_(0),
         num_responses_expected_(0),
         io_thread_("io_thread") {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread_.StartWithOptions(thread_options));
 
     request_context_getter_ = new TestURLRequestContextGetter(
         io_thread_.message_loop_proxy());
 
     server_.reset(new EmbeddedTestServer);
     ASSERT_TRUE(server_->InitializeAndWaitUntilReady());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete());
   }
 
   // URLFetcherDelegate override.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const URLFetcher* source) override {
     ++num_responses_received_;
     if (num_responses_received_ == num_responses_expected_)
       base::MessageLoop::current()->Quit();
   }
 
   // Waits until the specified number of responses are received.
   void WaitForResponses(int num_responses) {
     num_responses_received_ = 0;
     num_responses_expected_ = num_responses;
     // Will be terminated in OnURLFetchComplete().
@@ skipping 173 matching lines @@
     : public base::PlatformThread::Delegate,
       public URLFetcherDelegate {
  public:
   EmbeddedTestServerThreadingTestDelegate(
       bool message_loop_present_on_initialize,
       bool message_loop_present_on_shutdown)
       : message_loop_present_on_initialize_(message_loop_present_on_initialize),
         message_loop_present_on_shutdown_(message_loop_present_on_shutdown) {}
 
   // base::PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_runner;
     base::Thread io_thread("io_thread");
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread.StartWithOptions(thread_options));
     io_thread_runner = io_thread.message_loop_proxy();
 
     scoped_ptr<base::MessageLoop> loop;
     if (message_loop_present_on_initialize_)
       loop.reset(new base::MessageLoopForIO);
@@ skipping 17 matching lines @@
     fetcher.reset();
 
     // Shut down.
     if (message_loop_present_on_shutdown_)
       loop.reset();
 
     ASSERT_TRUE(server.ShutdownAndWaitUntilComplete());
   }
 
   // URLFetcherDelegate override.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const URLFetcher* source) override {
     base::MessageLoop::current()->Quit();
   }
 
  private:
   bool message_loop_present_on_initialize_;
   bool message_loop_present_on_shutdown_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbeddedTestServerThreadingTestDelegate);
 };
 
 TEST_P(EmbeddedTestServerThreadingTest, RunTest) {
   // The actual test runs on a separate thread so it can screw with the presence
   // of a MessageLoop - the test suite already sets up a MessageLoop for the
   // main test thread.
   base::PlatformThreadHandle thread_handle;
   EmbeddedTestServerThreadingTestDelegate delegate(
       std::tr1::get<0>(GetParam()),
       std::tr1::get<1>(GetParam()));
   ASSERT_TRUE(base::PlatformThread::Create(0, &delegate, &thread_handle));
   base::PlatformThread::Join(thread_handle);
 }
 
 INSTANTIATE_TEST_CASE_P(EmbeddedTestServerThreadingTestInstantiation,
                         EmbeddedTestServerThreadingTest,
                         testing::Combine(testing::Bool(), testing::Bool()));
 
 }  // namespace test_server
 }  // namespace net