Standardize usage of virtual/override/final specifiers.

net/proxy/proxy_config_service_linux_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/proxy/proxy_config_service_linux.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 89 matching lines @@
     Reset();
   }
 
   // Zeroes all environment values.
   void Reset() {
     EnvVarValues zero_values = { 0 };
     values = zero_values;
   }
 
   // Begin base::Environment implementation.
-  virtual bool GetVar(const char* variable_name, std::string* result) override {
+  bool GetVar(const char* variable_name, std::string* result) override {
     std::map<std::string, const char**>::iterator it =
         table.find(variable_name);
     if (it != table.end() && *(it->second) != NULL) {
       // Note that the variable may be defined but empty.
       *result = *(it->second);
       return true;
     }
     return false;
   }
 
-  virtual bool SetVar(const char* variable_name, const std::string& new_value)
-      override {
+  bool SetVar(const char* variable_name,
+              const std::string& new_value) override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool UnSetVar(const char* variable_name) override {
+  bool UnSetVar(const char* variable_name) override {
     ADD_FAILURE();
     return false;
   }
   // End base::Environment implementation.
 
   // Intentionally public, for convenience when setting up a test.
   EnvVarValues values;
 
  private:
   std::map<std::string, const char**> table;
@@ skipping 30 matching lines @@
         &values.ignore_hosts;
     Reset();
   }
 
   // Zeros all environment values.
   void Reset() {
     GConfValues zero_values = { 0 };
     values = zero_values;
   }
 
-  virtual bool Init(
-      const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
-      const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
+  bool Init(const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
+            const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       override {
     task_runner_ = glib_task_runner;
     return true;
   }
 
-  virtual void ShutDown() override {}
+  void ShutDown() override {}
 
-  virtual bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate)
-      override {
+  bool SetUpNotifications(
+      ProxyConfigServiceLinux::Delegate* delegate) override {
     return true;
   }
 
-  virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() override {
+  const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
+      override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() override {
+  ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_TEST;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) override {
+  bool GetString(StringSetting key, std::string* result) override {
     const char* value = strings_table.Get(key);
     if (value) {
       *result = value;
       return true;
     }
     return false;
   }
 
-  virtual bool GetBool(BoolSetting key, bool* result) override {
+  bool GetBool(BoolSetting key, bool* result) override {
     BoolSettingValue value = bools_table.Get(key);
     switch (value) {
     case UNSET:
       return false;
     case TRUE:
       *result = true;
       break;
     case FALSE:
       *result = false;
     }
     return true;
   }
 
-  virtual bool GetInt(IntSetting key, int* result) override {
+  bool GetInt(IntSetting key, int* result) override {
     // We don't bother to distinguish unset keys from 0 values.
     *result = ints_table.Get(key);
     return true;
   }
 
-  virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) override {
+  bool GetStringList(StringListSetting key,
+                     std::vector<std::string>* result) override {
     *result = string_lists_table.Get(key);
     // We don't bother to distinguish unset keys from empty lists.
     return !result->empty();
   }
 
-  virtual bool BypassListIsReversed() override {
-    return false;
-  }
+  bool BypassListIsReversed() override { return false; }
 
-  virtual bool MatchHostsUsingSuffixMatching() override {
-    return false;
-  }
+  bool MatchHostsUsingSuffixMatching() override { return false; }
 
   // Intentionally public, for convenience when setting up a test.
   GConfValues values;
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   SettingsTable<StringSetting, const char*> strings_table;
   SettingsTable<BoolSetting, BoolSettingValue> bools_table;
   SettingsTable<IntSetting, int> ints_table;
   SettingsTable<StringListSetting,
@@ skipping 93 matching lines @@
   net::ProxyConfigService::ConfigAvailability get_latest_config_result_;
 };
 
 namespace net {
 
 // This test fixture is only really needed for the KDEConfigParser test case,
 // but all the test cases with the same prefix ("ProxyConfigServiceLinuxTest")
 // must use the same test fixture class (also "ProxyConfigServiceLinuxTest").
 class ProxyConfigServiceLinuxTest : public PlatformTest {
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     PlatformTest::SetUp();
     // Set up a temporary KDE home directory.
     std::string prefix("ProxyConfigServiceLinuxTest_user_home");
     base::CreateNewTempDirectory(prefix, &user_home_);
     kde_home_ = user_home_.Append(FILE_PATH_LITERAL(".kde"));
     base::FilePath path = kde_home_.Append(FILE_PATH_LITERAL("share"));
     path = path.Append(FILE_PATH_LITERAL("config"));
     base::CreateDirectory(path);
     kioslaverc_ = path.Append(FILE_PATH_LITERAL("kioslaverc"));
     // Set up paths but do not create the directory for .kde4.
     kde4_home_ = user_home_.Append(FILE_PATH_LITERAL(".kde4"));
     path = kde4_home_.Append(FILE_PATH_LITERAL("share"));
     kde4_config_ = path.Append(FILE_PATH_LITERAL("config"));
     kioslaverc4_ = kde4_config_.Append(FILE_PATH_LITERAL("kioslaverc"));
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     // Delete the temporary KDE home directory.
     base::DeleteFile(user_home_, true);
     PlatformTest::TearDown();
   }
 
   base::FilePath user_home_;
   // KDE3 paths.
   base::FilePath kde_home_;
   base::FilePath kioslaverc_;
   // KDE4 paths.
@@ skipping 1225 matching lines @@
     ProxyConfig config;
     sync_config_getter.SetupAndInitialFetch();
     EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
               sync_config_getter.SyncGetLatestProxyConfig(&config));
     EXPECT_TRUE(config.auto_detect());
     EXPECT_EQ(GURL(), config.pac_url());
   }
 }
 
 }  // namespace net