Standardize usage of virtual/override/final in net/

net/dns/host_resolver_impl_unittest.cc

Index: net/dns/host_resolver_impl_unittest.cc
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index dadc03dc7eec8c90f3de0b155706564094dd2916..017625f32876c51a6064ab86f7d4479c71e4fe63 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -125,11 +125,11 @@ class MockHostResolverProc : public HostResolverProc {
     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_;
@@ -166,7 +166,7 @@ class MockHostResolverProc : public HostResolverProc {
   }
 
  protected:
-  virtual ~MockHostResolverProc() {}
+  ~MockHostResolverProc() override {}
 
  private:
   mutable base::Lock lock_;
@@ -361,11 +361,11 @@ class LookupAttemptHostResolverProc : public HostResolverProc {
   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_);
@@ -401,7 +401,7 @@ class LookupAttemptHostResolverProc : public HostResolverProc {
   }
 
  protected:
-  virtual ~LookupAttemptHostResolverProc() {}
+  ~LookupAttemptHostResolverProc() override {}
 
  private:
   int attempt_number_to_resolve_;
@@ -439,7 +439,7 @@ class HostResolverImplTest : public testing::Test {
  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,
@@ -732,7 +732,7 @@ TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) {
 
 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.
@@ -761,7 +761,7 @@ TEST_F(HostResolverImplTest, CancelWithinCallback) {
 
 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());
 
@@ -787,7 +787,7 @@ TEST_F(HostResolverImplTest, DeleteWithinCallback) {
 
 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());
 
@@ -827,7 +827,7 @@ TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
 
 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.
@@ -858,7 +858,7 @@ TEST_F(HostResolverImplTest, StartWithinCallback) {
 
 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.
@@ -956,7 +956,7 @@ TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
 // 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;
@@ -1379,7 +1379,7 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
   }
 
   // HostResolverImplTest implementation:
-  virtual void CreateResolverWithLimitsAndParams(
+  void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) override {
     HostResolverImpl::Options options = DefaultOptions();