Standardize usage of virtual/override/final in content/

content/public/test/browser_test_base.cc

 // Copyright (c) 2011 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 "content/public/test/browser_test_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/i18n/icu_util.h"
@@ skipping 67 matching lines @@
 }
 
 // In many cases it may be not obvious that a test makes a real DNS lookup.
 // We generally don't want to rely on external DNS servers for our tests,
 // so this host resolver procedure catches external queries and returns a failed
 // lookup result.
 class LocalHostResolverProc : public net::HostResolverProc {
  public:
   LocalHostResolverProc() : HostResolverProc(NULL) {}
 
-  virtual int Resolve(const std::string& host,
-                      net::AddressFamily address_family,
-                      net::HostResolverFlags host_resolver_flags,
-                      net::AddressList* addrlist,
-                      int* os_error) override {
+  int Resolve(const std::string& host,
+              net::AddressFamily address_family,
+              net::HostResolverFlags host_resolver_flags,
+              net::AddressList* addrlist,
+              int* os_error) override {
     const char* kLocalHostNames[] = {"localhost", "127.0.0.1", "::1"};
     bool local = false;
 
     if (host == net::GetHostName()) {
       local = true;
     } else {
       for (size_t i = 0; i < arraysize(kLocalHostNames); i++)
         if (host == kLocalHostNames[i]) {
           local = true;
           break;
         }
     }
 
     // To avoid depending on external resources and to reduce (if not preclude)
     // network interactions from tests, we simulate failure for non-local DNS
     // queries, rather than perform them.
     // If you really need to make an external DNS query, use
     // net::RuleBasedHostResolverProc and its AllowDirectLookup method.
     if (!local) {
       DVLOG(1) << "To avoid external dependencies, simulating failure for "
           "external DNS lookup of " << host;
       return net::ERR_NOT_IMPLEMENTED;
     }
 
     return ResolveUsingPrevious(host, address_family, host_resolver_flags,
                                 addrlist, os_error);
   }
 
  private:
-  virtual ~LocalHostResolverProc() {}
+  ~LocalHostResolverProc() override {}
 };
 
 void TraceDisableRecordingComplete(const base::Closure& quit,
                                    const base::FilePath& file_path) {
   LOG(ERROR) << "Tracing written to: " << file_path.value();
   quit.Run();
 }
 
 }  // namespace
 
@@ skipping 207 matching lines @@
   use_software_compositing_ = true;
 }
 
 bool BrowserTestBase::UsingOSMesa() const {
   CommandLine* cmd = CommandLine::ForCurrentProcess();
   return cmd->GetSwitchValueASCII(switches::kUseGL) ==
          gfx::kGLImplementationOSMesaName;
 }
 
 }  // namespace content