replace OVERRIDE and FINAL with override and final in net/

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 {
+  virtual 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 {
+      override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool UnSetVar(const char* variable_name) OVERRIDE {
+  virtual 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 33 matching lines @@
 
   // 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)
-      OVERRIDE {
+      override {
     task_runner_ = glib_task_runner;
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {}
+  virtual void ShutDown() override {}
 
   virtual bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate)
-      OVERRIDE {
+      override {
     return true;
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_TEST;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual 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 {
+  virtual 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 {
+  virtual 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 {
+                             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 {
+  virtual bool BypassListIsReversed() override {
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual 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;
@@ skipping 95 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 {
+  virtual 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 {
+  virtual 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