Linux: split ProxyConfigServiceLinux::SettingGetter::Setting into several enums.

net/proxy/proxy_config_service_linux_unittest.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 "net/proxy/proxy_config_service_linux.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 45 matching lines @@
   // integers
   int http_port, secure_port, ftp_port, socks_port;
   // booleans
   BoolSettingValue use_proxy, same_proxy, use_auth;
   // string list
   std::vector<std::string> ignore_hosts;
 };
 
 // Mapping from a setting name to the location of the corresponding
 // value (inside a EnvVarValues or GConfValues struct).
-template<typename value_type>
+template<typename key_type, typename value_type>
 struct SettingsTable {
-  typedef ProxyConfigServiceLinux::SettingGetter::Setting Setting;
-  typedef std::map<Setting, value_type*> map_type;
+  typedef std::map<key_type, value_type*> map_type;
 
   // Gets the value from its location
-  value_type Get(Setting key) {
+  value_type Get(key_type key) {
     typename map_type::const_iterator it = settings.find(key);
     // In case there's a typo or the unittest becomes out of sync.
     CHECK(it != settings.end()) << "key " << key << " not found";
     value_type* value_ptr = it->second;
     return *value_ptr;
   }
 
   map_type settings;
 };
 
@@ skipping 103 matching lines @@
   }
 
   virtual MessageLoop* GetNotificationLoop() {
     return NULL;
   }
 
   virtual const char* GetDataSource() {
     return "test";
   }
 
-  virtual bool GetString(Setting key, std::string* result) {
+  virtual bool GetString(StringSetting key, std::string* result) {
     const char* value = strings_table.Get(key);
     if (value) {
       *result = value;
       return true;
     }
     return false;
   }
 
-  virtual bool GetInt(Setting key, int* result) {
-    // We don't bother to distinguish unset keys from 0 values.
-    *result = ints_table.Get(key);
-    return true;
-  }
-
-  virtual bool GetBool(Setting key, bool* result) {
+  virtual bool GetBool(BoolSetting key, bool* result) {
     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 GetStringList(Setting key, std::vector<std::string>* result) {
+  virtual bool GetInt(IntSetting key, int* result) {
+    // 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) {
     *result = string_lists_table.Get(key);
     // We don't bother to distinguish unset keys from empty lists.
     return !result->empty();
   }
 
   virtual bool BypassListIsReversed() {
     return false;
   }
 
   virtual bool MatchHostsUsingSuffixMatching() {
     return false;
   }
 
   // Intentionally public, for convenience when setting up a test.
   GConfValues values;
 
  private:
-  SettingsTable<const char*> strings_table;
-  SettingsTable<int> ints_table;
-  SettingsTable<BoolSettingValue> bools_table;
-  SettingsTable<std::vector<std::string> > string_lists_table;
+  SettingsTable<StringSetting, const char*> strings_table;
+  SettingsTable<BoolSetting, BoolSettingValue> bools_table;
+  SettingsTable<IntSetting, int> ints_table;
+  SettingsTable<StringListSetting,
+                std::vector<std::string> > string_lists_table;
 };
 
 }  // namespace
 }  // namespace net
 
 // This helper class runs ProxyConfigServiceLinux::GetLatestProxyConfig() on
 // the IO thread and synchronously waits for the result.
 // Some code duplicated from proxy_script_fetcher_unittest.cc.
 class SynchConfigGetter {
  public:
@@ skipping 1281 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