replace OVERRIDE and FINAL with override and final in net/

net/dns/host_resolver_impl_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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 111 matching lines @@
     DCHECK_EQ(OK, rv);
     AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result);
     AddRule(hostname, ADDRESS_FAMILY_IPV4, result);
     AddRule(hostname, ADDRESS_FAMILY_IPV6, result);
   }
 
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) OVERRIDE {
+                      int* os_error) override {
     base::AutoLock lock(lock_);
     capture_list_.push_back(ResolveKey(hostname, address_family));
     ++num_requests_waiting_;
     requests_waiting_.Broadcast();
     while (!num_slots_available_)
       slots_available_.Wait();
     DCHECK_GT(num_requests_waiting_, 0u);
     --num_slots_available_;
     --num_requests_waiting_;
     if (rules_.empty()) {
@@ skipping 215 matching lines @@
   int total_attempts_resolved() { return total_attempts_resolved_; }
 
   // Returns the first attempt that that has resolved the host.
   int resolved_attempt_number() { return resolved_attempt_number_; }
 
   // HostResolverProc methods.
   virtual int Resolve(const std::string& host,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) OVERRIDE {
+                      int* os_error) override {
     bool wait_for_right_attempt_to_complete = true;
     {
       base::AutoLock auto_lock(lock_);
       ++current_attempt_number_;
       if (current_attempt_number_ == attempt_number_to_resolve_) {
         resolved_attempt_number_ = current_attempt_number_;
         wait_for_right_attempt_to_complete = false;
       }
     }
 
@@ skipping 74 matching lines @@
       return test->CreateRequest(hostname);
     }
     ScopedVector<Request>& requests() { return test->requests_; }
 
     void DeleteResolver() { test->resolver_.reset(); }
 
     HostResolverImplTest* test;
   };
 
   // testing::Test implementation:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     CreateResolver();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (resolver_.get())
       EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
     EXPECT_FALSE(proc_->HasBlockedRequests());
   }
 
   virtual void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) {
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
@@ skipping 247 matching lines @@
 
   proc_->SignalAll();
 
   size_t num_requests = requests_.size();
   EXPECT_EQ(OK, requests_[num_requests - 1]->WaitForResult());
   EXPECT_EQ(OK, requests_[num_requests - 2]->result());
 }
 
 TEST_F(HostResolverImplTest, CancelWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       // Port 80 is the first request that the callback will be invoked for.
       // While we are executing within that callback, cancel the other requests
       // in the job and start another request.
       if (req->index() == 0) {
         // Once "a:80" completes, it will cancel "a:81" and "a:82".
         requests()[1]->Cancel();
         requests()[2]->Cancel();
       }
     }
   };
   set_handler(new MyHandler());
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for "finalrequest".
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
 
   Request* final_request = CreateRequest("finalrequest", 70);
   EXPECT_EQ(ERR_IO_PENDING, final_request->Resolve());
   EXPECT_EQ(OK, final_request->WaitForResult());
   EXPECT_TRUE(requests_[3]->completed());
 }
 
 TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
       DeleteResolver();
 
       // Quit after returning from OnCompleted (to give it a chance at
       // incorrectly running the cancelled tasks).
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
     }
   };
   set_handler(new MyHandler());
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(1u);  // One for "a".
 
   // |MyHandler| will send quit message once all the requests have finished.
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
       DeleteResolver();
 
       // Quit after returning from OnCompleted (to give it a chance at
       // incorrectly running the cancelled tasks).
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
     }
@@ skipping 19 matching lines @@
   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result());
   EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result());
   // Clean up.
   proc_->SignalMultiple(requests_.size());
 }
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is disabled, this will result in another async request.
         EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
       }
     }
   };
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   ASSERT_EQ(5u, requests_.size());
   EXPECT_EQ(OK, requests_.back()->WaitForResult());
 
   EXPECT_EQ(2u, proc_->GetCaptureList().size());
 }
 
 TEST_F(HostResolverImplTest, BypassCache) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is enabled, this should complete synchronously.
         std::string hostname = req->info().hostname();
         EXPECT_EQ(OK, CreateRequest(hostname, 70)->Resolve());
         EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache());
 
         // Ok good. Now make sure that if we ask to bypass the cache, it can no
         // longer service the request synchronously.
         HostResolver::RequestInfo info(HostPortPair(hostname, 71));
@@ skipping 77 matching lines @@
   EXPECT_FALSE(requests_[2]->completed());
 
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_EQ(OK, requests_[1]->result());
 }
 
 // Tests that a new Request made from the callback of a previously aborted one
 // will not be aborted.
 TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       // Start new request for a different hostname to ensure that the order
       // of jobs in HostResolverImpl is not stable.
       std::string hostname;
       if (req->index() == 0)
         hostname = "zzz";
       else if (req->index() == 1)
         hostname = "aaa";
       else if (req->index() == 2)
         hostname = "eee";
       else
@@ skipping 362 matching lines @@
   return config;
 }
 
 // Specialized fixture for tests of DnsTask.
 class HostResolverImplDnsTest : public HostResolverImplTest {
  public:
   HostResolverImplDnsTest() : dns_client_(NULL) {}
 
  protected:
   // testing::Test implementation:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL, false);
     AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
     AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
     AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY, false);
     AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY, false);
     AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK, false);
     AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
     AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
@@ skipping 21 matching lines @@
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeA,
                MockDnsClientRule::OK, true);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
                MockDnsClientRule::TIMEOUT, false);
     CreateResolver();
   }
 
   // HostResolverImplTest implementation:
   virtual void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
-      const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
+      const HostResolverImpl::ProcTaskParams& params) override {
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
     resolver_.reset(new HostResolverImpl(options, NULL));
     resolver_->set_proc_params_for_test(params);
     // Disable IPv6 support probing.
     resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
     resolver_->SetDnsClient(scoped_ptr<DnsClient>(dns_client_));
   }
 
@@ skipping 703 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 }  // namespace net