Linux: refactor ProxyConfigServiceLinux to use an enum of setting ids rather than gconf key names.

This will make it easier to add a third way to get proxy settings, via the new gsettings API.

BUG=80453
TEST=proxy settings still work as expected on linux
Review URL: http://codereview.chromium.org/7027002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85686 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 47 insertions, 45 deletions

diff --git a/net/proxy/proxy_config_service_linux_unittest.cc b/net/proxy/proxy_config_service_linux_unittest.cc
index 5244b66..8d37e07 100644
--- a/net/proxy/proxy_config_service_linux_unittest.cc
+++ b/net/proxy/proxy_config_service_linux_unittest.cc
@@ -65,10 +65,11 @@ struct GConfValues {
 // value (inside a EnvVarValues or GConfValues struct).
 template<typename value_type>
 struct SettingsTable {
-  typedef std::map<std::string, value_type*> map_type;
+  typedef ProxyConfigServiceLinux::SettingGetter::Setting Setting;
+  typedef std::map<Setting, value_type*> map_type;
 
   // Gets the value from its location
-  value_type Get(const std::string& key) {
+  value_type Get(Setting 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";
@@ -82,7 +83,7 @@ struct SettingsTable {
 class MockEnvironment : public base::Environment {
  public:
   MockEnvironment() {
-#define ENTRY(x) table.settings[#x] = &values.x
+#define ENTRY(x) table[#x] = &values.x
     ENTRY(DESKTOP_SESSION);
     ENTRY(HOME);
     ENTRY(KDEHOME);
@@ -99,7 +100,7 @@ class MockEnvironment : public base::Environment {
     Reset();
   }
 
-  // Zeros all environment values.
+  // Zeroes all environment values.
   void Reset() {
     EnvVarValues zero_values = { 0 };
     values = zero_values;
@@ -107,10 +108,11 @@ class MockEnvironment : public base::Environment {
 
   // Begin base::Environment implementation.
   virtual bool GetVar(const char* variable_name, std::string* result) {
-    const char* env_value = table.Get(variable_name);
-    if (env_value) {
+    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 = env_value;
+      *result = *(it->second);
       return true;
     }
     return false;
@@ -131,37 +133,38 @@ class MockEnvironment : public base::Environment {
   EnvVarValues values;
 
  private:
-  SettingsTable<const char*> table;
+  std::map<std::string, const char**> table;
 };
 
-class MockGConfSettingGetter
-    : public ProxyConfigServiceLinux::GConfSettingGetter {
+class MockSettingGetter
+    : public ProxyConfigServiceLinux::SettingGetter {
  public:
-  MockGConfSettingGetter() {
+  typedef ProxyConfigServiceLinux::SettingGetter SettingGetter;
+  MockSettingGetter() {
 #define ENTRY(key, field) \
-      strings_table.settings["/system/" key] = &values.field
-    ENTRY("proxy/mode", mode);
-    ENTRY("proxy/autoconfig_url", autoconfig_url);
-    ENTRY("http_proxy/host", http_host);
-    ENTRY("proxy/secure_host", secure_host);
-    ENTRY("proxy/ftp_host", ftp_host);
-    ENTRY("proxy/socks_host", socks_host);
+      strings_table.settings[SettingGetter::key] = &values.field
+    ENTRY(PROXY_MODE, mode);
+    ENTRY(PROXY_AUTOCONF_URL, autoconfig_url);
+    ENTRY(PROXY_HTTP_HOST, http_host);
+    ENTRY(PROXY_HTTPS_HOST, secure_host);
+    ENTRY(PROXY_FTP_HOST, ftp_host);
+    ENTRY(PROXY_SOCKS_HOST, socks_host);
 #undef ENTRY
 #define ENTRY(key, field) \
-      ints_table.settings["/system/" key] = &values.field
-    ENTRY("http_proxy/port", http_port);
-    ENTRY("proxy/secure_port", secure_port);
-    ENTRY("proxy/ftp_port", ftp_port);
-    ENTRY("proxy/socks_port", socks_port);
+      ints_table.settings[SettingGetter::key] = &values.field
+    ENTRY(PROXY_HTTP_PORT, http_port);
+    ENTRY(PROXY_HTTPS_PORT, secure_port);
+    ENTRY(PROXY_FTP_PORT, ftp_port);
+    ENTRY(PROXY_SOCKS_PORT, socks_port);
 #undef ENTRY
 #define ENTRY(key, field) \
-      bools_table.settings["/system/" key] = &values.field
-    ENTRY("http_proxy/use_http_proxy", use_proxy);
-    ENTRY("http_proxy/use_same_proxy", same_proxy);
-    ENTRY("http_proxy/use_authentication", use_auth);
+      bools_table.settings[SettingGetter::key] = &values.field
+    ENTRY(PROXY_USE_HTTP_PROXY, use_proxy);
+    ENTRY(PROXY_USE_SAME_PROXY, same_proxy);
+    ENTRY(PROXY_USE_AUTHENTICATION, use_auth);
 #undef ENTRY
-    string_lists_table.settings["/system/http_proxy/ignore_hosts"] =
-      &values.ignore_hosts;
+    string_lists_table.settings[SettingGetter::PROXY_IGNORE_HOSTS] =
+        &values.ignore_hosts;
     Reset();
   }
 
@@ -190,7 +193,7 @@ class MockGConfSettingGetter
     return "test";
   }
 
-  virtual bool GetString(const char* key, std::string* result) {
+  virtual bool GetString(Setting key, std::string* result) {
     const char* value = strings_table.Get(key);
     if (value) {
       *result = value;
@@ -199,13 +202,13 @@ class MockGConfSettingGetter
     return false;
   }
 
-  virtual bool GetInt(const char* key, int* result) {
+  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 GetBoolean(const char* key, bool* result) {
+  virtual bool GetBool(Setting key, bool* result) {
     BoolSettingValue value = bools_table.Get(key);
     switch (value) {
     case UNSET:
@@ -219,8 +222,7 @@ class MockGConfSettingGetter
     return true;
   }
 
-  virtual bool GetStringList(const char* key,
-                             std::vector<std::string>* result) {
+  virtual bool GetStringList(Setting 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();
@@ -676,11 +678,11 @@ TEST_F(ProxyConfigServiceLinuxTest, BasicGConfTest) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
-    MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
+    MockSettingGetter* setting_getter = new MockSettingGetter;
     SynchConfigGetter sync_config_getter(
-        new ProxyConfigServiceLinux(env, gconf_getter));
+        new ProxyConfigServiceLinux(env, setting_getter));
     ProxyConfig config;
-    gconf_getter->values = tests[i].values;
+    setting_getter->values = tests[i].values;
     sync_config_getter.SetupAndInitialFetch();
     ProxyConfigService::ConfigAvailability availability =
         sync_config_getter.SyncGetLatestProxyConfig(&config);
@@ -984,9 +986,9 @@ TEST_F(ProxyConfigServiceLinuxTest, BasicEnvTest) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "] %s", i,
                                     tests[i].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
-    MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
+    MockSettingGetter* setting_getter = new MockSettingGetter;
     SynchConfigGetter sync_config_getter(
-        new ProxyConfigServiceLinux(env, gconf_getter));
+        new ProxyConfigServiceLinux(env, setting_getter));
     ProxyConfig config;
     env->values = tests[i].values;
     sync_config_getter.SetupAndInitialFetch();
@@ -1004,22 +1006,22 @@ TEST_F(ProxyConfigServiceLinuxTest, BasicEnvTest) {
 
 TEST_F(ProxyConfigServiceLinuxTest, GconfNotification) {
   MockEnvironment* env = new MockEnvironment;
-  MockGConfSettingGetter* gconf_getter = new MockGConfSettingGetter;
+  MockSettingGetter* setting_getter = new MockSettingGetter;
   ProxyConfigServiceLinux* service =
-      new ProxyConfigServiceLinux(env, gconf_getter);
+      new ProxyConfigServiceLinux(env, setting_getter);
   SynchConfigGetter sync_config_getter(service);
   ProxyConfig config;
 
   // Start with no proxy.
-  gconf_getter->values.mode = "none";
+  setting_getter->values.mode = "none";
   sync_config_getter.SetupAndInitialFetch();
   EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
             sync_config_getter.SyncGetLatestProxyConfig(&config));
   EXPECT_FALSE(config.auto_detect());
 
   // Now set to auto-detect.
-  gconf_getter->values.mode = "auto";
-  // Simulate gconf notification callback.
+  setting_getter->values.mode = "auto";
+  // Simulate setting change notification callback.
   service->OnCheckProxyConfigSettings();
   EXPECT_EQ(ProxyConfigService::CONFIG_VALID,
             sync_config_getter.SyncGetLatestProxyConfig(&config));
@@ -1030,7 +1032,7 @@ TEST_F(ProxyConfigServiceLinuxTest, KDEConfigParser) {
   // One of the tests below needs a worst-case long line prefix. We build it
   // programmatically so that it will always be the right size.
   std::string long_line;
-  size_t limit = ProxyConfigServiceLinux::GConfSettingGetter::BUFFER_SIZE - 1;
+  size_t limit = ProxyConfigServiceLinux::SettingGetter::BUFFER_SIZE - 1;
   for (size_t i = 0; i < limit; ++i)
     long_line += "-";