Standardize usage of virtual/override/final in net/

net/proxy/proxy_resolver_v8_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 "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_v8.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 namespace {
 
 // Javascript bindings for ProxyResolverV8, which returns mock values.
 // Each time one of the bindings is called into, we push the input into a
 // list, for later verification.
 class MockJSBindings : public ProxyResolverV8::JSBindings {
  public:
   MockJSBindings() : my_ip_address_count(0), my_ip_address_ex_count(0),
                      should_terminate(false) {}
 
-  virtual void Alert(const base::string16& message) override {
+  void Alert(const base::string16& message) override {
     VLOG(1) << "PAC-alert: " << message;  // Helpful when debugging.
     alerts.push_back(base::UTF16ToUTF8(message));
   }
 
-  virtual bool ResolveDns(const std::string& host,
-                          ResolveDnsOperation op,
-                          std::string* output,
-                          bool* terminate) override {
+  bool ResolveDns(const std::string& host,
+                  ResolveDnsOperation op,
+                  std::string* output,
+                  bool* terminate) override {
     *terminate = should_terminate;
 
     if (op == MY_IP_ADDRESS) {
       my_ip_address_count++;
       *output = my_ip_address_result;
       return !my_ip_address_result.empty();
     }
 
     if (op == MY_IP_ADDRESS_EX) {
       my_ip_address_ex_count++;
@@ skipping 10 matching lines @@
     if (op == DNS_RESOLVE_EX) {
       dns_resolves_ex.push_back(host);
       *output = dns_resolve_ex_result;
       return !dns_resolve_ex_result.empty();
     }
 
     CHECK(false);
     return false;
   }
 
-  virtual void OnError(int line_number,
-                       const base::string16& message) override {
+  void OnError(int line_number, const base::string16& message) override {
     // Helpful when debugging.
     VLOG(1) << "PAC-error: [" << line_number << "] " << message;
 
     errors.push_back(base::UTF16ToUTF8(message));
     errors_line_number.push_back(line_number);
   }
 
   // Mock values to return.
   std::string my_ip_address_result;
   std::string my_ip_address_ex_result;
@@ skipping 15 matching lines @@
 
 // This is the same as ProxyResolverV8, but it uses mock bindings in place of
 // the default bindings, and has a helper function to load PAC scripts from
 // disk.
 class ProxyResolverV8WithMockBindings : public ProxyResolverV8 {
  public:
   ProxyResolverV8WithMockBindings() {
     set_js_bindings(&mock_js_bindings_);
   }
 
-  virtual ~ProxyResolverV8WithMockBindings() {
-  }
+  ~ProxyResolverV8WithMockBindings() override {}
 
   MockJSBindings* mock_js_bindings() {
     return &mock_js_bindings_;
   }
 
   // Initialize with the PAC script data at |filename|.
   int SetPacScriptFromDisk(const char* filename) {
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.AppendASCII("net");
@@ skipping 501 matching lines @@
       GURL("http://kittens/"), &proxy_info,
       CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_EQ(0u, bindings->errors.size());
   EXPECT_EQ("kittens:88", proxy_info.proxy_server().ToURI());
 }
 
 }  // namespace
 }  // namespace net