Standardize usage of virtual/override/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 107 matching lines @@
   void AddRuleForAllFamilies(const std::string& hostname,
                              const std::string& ip_list) {
     AddressList result;
     int rv = ParseAddressList(ip_list, std::string(), &result);
     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 Resolve(const std::string& hostname,
+              AddressFamily address_family,
+              HostResolverFlags host_resolver_flags,
+              AddressList* addrlist,
+              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 16 matching lines @@
     }
     return copy;
   }
 
   bool HasBlockedRequests() const {
     base::AutoLock lock(lock_);
     return num_requests_waiting_ > num_slots_available_;
   }
 
  protected:
-  virtual ~MockHostResolverProc() {}
+  ~MockHostResolverProc() override {}
 
  private:
   mutable base::Lock lock_;
   std::map<ResolveKey, AddressList> rules_;
   CaptureList capture_list_;
   unsigned num_requests_waiting_;
   unsigned num_slots_available_;
   base::ConditionVariable requests_waiting_;
   base::ConditionVariable slots_available_;
 
@@ skipping 174 matching lines @@
     all_done_.Broadcast();  // Tell all waiting attempts to proceed.
   }
 
   // Returns the number of attempts that have finished the Resolve() method.
   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 Resolve(const std::string& host,
+              AddressFamily address_family,
+              HostResolverFlags host_resolver_flags,
+              AddressList* addrlist,
+              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 15 matching lines @@
     // special meaning (ERR_IO_PENDING). We could return the attempt that has
     // resolved the host as a negative number. For example, if attempt number 3
     // resolves the host, then this method returns -4.
     if (result == OK)
       return -1 - resolved_attempt_number_;
     else
       return result;
   }
 
  protected:
-  virtual ~LookupAttemptHostResolverProc() {}
+  ~LookupAttemptHostResolverProc() override {}
 
  private:
   int attempt_number_to_resolve_;
   int current_attempt_number_;  // Incremented whenever Resolve is called.
   int total_attempts_;
   int total_attempts_resolved_;
   int resolved_attempt_number_;
 
   // All attempts wait for right attempt to be resolve.
   base::Lock lock_;
@@ skipping 17 matching lines @@
   // perform no retries.
   void CreateSerialResolver() {
     HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get());
     params.max_retry_attempts = 0u;
     CreateResolverWithLimitsAndParams(1u, params);
   }
 
  protected:
   // A Request::Handler which is a proxy to the HostResolverImplTest fixture.
   struct Handler : public Request::Handler {
-    virtual ~Handler() {}
+    ~Handler() override {}
 
     // Proxy functions so that classes derived from Handler can access them.
     Request* CreateRequest(const HostResolver::RequestInfo& info,
                            RequestPriority priority) {
       return test->CreateRequest(info, priority);
     }
     Request* CreateRequest(const std::string& hostname, int port) {
       return test->CreateRequest(hostname, port);
     }
     Request* CreateRequest(const std::string& hostname) {
@@ skipping 272 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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 402 matching lines @@
     AddDnsRule("4slow_4timeout", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
                false);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeA,
                MockDnsClientRule::OK, true);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
                MockDnsClientRule::TIMEOUT, false);
     CreateResolver();
   }
 
   // HostResolverImplTest implementation:
-  virtual void CreateResolverWithLimitsAndParams(
+  void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
       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 705 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