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

net/proxy/proxy_config_service_linux.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 <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 281 matching lines @@
   }
 
   virtual MessageLoop* GetNotificationLoop() {
     return loop_;
   }
 
   virtual const char* GetDataSource() {
     return "gconf";
   }
 
-  virtual bool GetString(Setting key, std::string* result) {
+  virtual bool GetString(StringSetting key, std::string* result) {
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath("/system/proxy/mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath("/system/proxy/autoconfig_url", result);
       case PROXY_HTTP_HOST:
         return GetStringByPath("/system/http_proxy/host", result);
       case PROXY_HTTPS_HOST:
         return GetStringByPath("/system/proxy/secure_host", result);
       case PROXY_FTP_HOST:
         return GetStringByPath("/system/proxy/ftp_host", result);
       case PROXY_SOCKS_HOST:
         return GetStringByPath("/system/proxy/socks_host", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler

[vandebo (ex-Chrome), 2011/05/20 20:05:49]

nit: Comments should be sentences... "Placate compiler."

[Mike Mammarella, 2011/05/20 20:42:36]

Done.

   }
-  virtual bool GetBool(Setting key, bool* result) {
+  virtual bool GetBool(BoolSetting key, bool* result) {
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
         return GetBoolByPath("/system/http_proxy/use_http_proxy", result);
       case PROXY_USE_SAME_PROXY:
         return GetBoolByPath("/system/http_proxy/use_same_proxy", result);
       case PROXY_USE_AUTHENTICATION:
         return GetBoolByPath("/system/http_proxy/use_authentication", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
-  virtual bool GetInt(Setting key, int* result) {
+  virtual bool GetInt(IntSetting key, int* result) {
     switch (key) {
       case PROXY_HTTP_PORT:
         return GetIntByPath("/system/http_proxy/port", result);
       case PROXY_HTTPS_PORT:
         return GetIntByPath("/system/proxy/secure_port", result);
       case PROXY_FTP_PORT:
         return GetIntByPath("/system/proxy/ftp_port", result);
       case PROXY_SOCKS_PORT:
         return GetIntByPath("/system/proxy/socks_port", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
-  virtual bool GetStringList(Setting key, std::vector<std::string>* result) {
+  virtual bool GetStringList(StringListSetting key,
+                             std::vector<std::string>* result) {
     switch (key) {
       case PROXY_IGNORE_HOSTS:
         return GetStringListByPath("/system/http_proxy/ignore_hosts", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
 
   virtual bool BypassListIsReversed() {
     // This is a KDE-specific setting.
     return false;
   }
 
   virtual bool MatchHostsUsingSuffixMatching() {
     return false;
   }
@@ skipping 221 matching lines @@
   }
 
   virtual MessageLoop* GetNotificationLoop() {
     return loop_;
   }
 
   virtual const char* GetDataSource() {
     return "gsettings";
   }
 
-  virtual bool GetString(Setting key, std::string* result) {
+  virtual bool GetString(StringSetting key, std::string* result) {
     DCHECK(client_);
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath(client_, "mode", result);
       case PROXY_AUTOCONF_URL:
         return GetStringByPath(client_, "autoconfig-url", result);
       case PROXY_HTTP_HOST:
         return GetStringByPath(http_client_, "host", result);
       case PROXY_HTTPS_HOST:
         return GetStringByPath(https_client_, "host", result);
       case PROXY_FTP_HOST:
         return GetStringByPath(ftp_client_, "host", result);
       case PROXY_SOCKS_HOST:
         return GetStringByPath(socks_client_, "host", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
-  virtual bool GetBool(Setting key, bool* result) {
+  virtual bool GetBool(BoolSetting key, bool* result) {
     DCHECK(client_);
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
         // Although there is an "enabled" boolean in http_client_, it is not set
         // to true by the proxy config utility. We ignore it and return false.
         return false;
       case PROXY_USE_SAME_PROXY:
         // Similarly, although there is a "use-same-proxy" boolean in client_,
         // it is never set to false by the proxy config utility. We ignore it.
         return false;
       case PROXY_USE_AUTHENTICATION:
         // There is also no way to set this in the proxy config utility, but it
         // doesn't hurt us to get the actual setting (unlike the two above).
         return GetBoolByPath(http_client_, "use-authentication", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
-  virtual bool GetInt(Setting key, int* result) {
+  virtual bool GetInt(IntSetting key, int* result) {
     DCHECK(client_);
     switch (key) {
       case PROXY_HTTP_PORT:
         return GetIntByPath(http_client_, "port", result);
       case PROXY_HTTPS_PORT:
         return GetIntByPath(https_client_, "port", result);
       case PROXY_FTP_PORT:
         return GetIntByPath(ftp_client_, "port", result);
       case PROXY_SOCKS_PORT:
         return GetIntByPath(socks_client_, "port", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
-  virtual bool GetStringList(Setting key, std::vector<std::string>* result) {
+  virtual bool GetStringList(StringListSetting key,
+                             std::vector<std::string>* result) {
     DCHECK(client_);
     switch (key) {
       case PROXY_IGNORE_HOSTS:
         return GetStringListByPath(client_, "ignore-hosts", result);
-      default:
-        return false;
     }
+    return false;  // placate compiler
   }
 
   virtual bool BypassListIsReversed() {
     // This is a KDE-specific setting.
     return false;
   }
 
   virtual bool MatchHostsUsingSuffixMatching() {
     return false;
   }
@@ skipping 322 matching lines @@
     OnChangeNotification();
   }
   void OnFileCanWriteWithoutBlocking(int fd) {
     NOTREACHED();
   }
 
   virtual const char* GetDataSource() {
     return "KDE";
   }
 
-  virtual bool GetString(Setting key, std::string* result) {
+  virtual bool GetString(StringSetting key, std::string* result) {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
       return false;
     *result = it->second;
     return true;
   }
-  virtual bool GetBool(Setting key, bool* result) {
+  virtual bool GetBool(BoolSetting key, bool* result) {
     // We don't ever have any booleans.
     return false;
   }
-  virtual bool GetInt(Setting key, int* result) {
+  virtual bool GetInt(IntSetting key, int* result) {
     // We don't ever have any integers. (See AddProxy() below about ports.)
     return false;
   }
-  virtual bool GetStringList(Setting key, std::vector<std::string>* result) {
+  virtual bool GetStringList(StringListSetting key,
+                             std::vector<std::string>* result) {
     strings_map_type::iterator it = strings_table_.find(key);
     if (it == strings_table_.end())
       return false;
     *result = it->second;
     return true;
   }
 
   virtual bool BypassListIsReversed() {
     return reversed_bypass_list_;
   }
 
   virtual bool MatchHostsUsingSuffixMatching() {
     return true;
   }
 
  private:
   void ResetCachedSettings() {
     string_table_.clear();
     strings_table_.clear();
     indirect_manual_ = false;
     auto_no_pac_ = false;
     reversed_bypass_list_ = false;
   }
 
   FilePath KDEHomeToConfigPath(const FilePath& kde_home) {
     return kde_home.Append("share").Append("config");
   }
 
-  void AddProxy(Setting host_key, const std::string& value) {
+  void AddProxy(StringSetting host_key, const std::string& value) {
     if (value.empty() || value.substr(0, 3) == "//:")
       // No proxy.
       return;
     // We don't need to parse the port number out; GetProxyFromSettings()
     // would only append it right back again. So we just leave the port
     // number right in the host string.
     string_table_[host_key] = value;
   }
 
-  void AddHostList(Setting key, const std::string& value) {
+  void AddHostList(StringListSetting key, const std::string& value) {
     std::vector<std::string> tokens;
     StringTokenizer tk(value, ", ");
     while (tk.GetNext()) {
       std::string token = tk.token();
       if (!token.empty())
         tokens.push_back(token);
     }
     strings_table_[key] = tokens;
   }
 
@@ skipping 52 matching lines @@
       base::StringToInt(value, &mode);
       if (mode) {
         // ProxyConfig does not support authentication parameters, but
         // Chrome will prompt for the password later. So we ignore this.
         LOG(WARNING) <<
             "Proxy authentication parameters ignored, see bug 16709";
       }
     }
   }
 
-  void ResolveIndirect(Setting key) {
+  void ResolveIndirect(StringSetting key) {
     string_map_type::iterator it = string_table_.find(key);
     if (it != string_table_.end()) {
       std::string value;
       if (env_var_getter_->GetVar(it->second.c_str(), &value))
         it->second = value;
       else
         string_table_.erase(it);
     }
   }
 
-  void ResolveIndirectList(Setting key) {
+  void ResolveIndirectList(StringListSetting key) {
     strings_map_type::iterator it = strings_table_.find(key);
     if (it != strings_table_.end()) {
       std::string value;
       if (!it->second.empty() &&
           env_var_getter_->GetVar(it->second[0].c_str(), &value))
         AddHostList(key, value);
       else
         strings_table_.erase(it);
     }
   }
@@ skipping 149 matching lines @@
     if (kioslaverc_touched) {
       // We don't use Reset() because the timer may not yet be running.
       // (In that case Stop() is a no-op.)
       debounce_timer_.Stop();
       debounce_timer_.Start(base::TimeDelta::FromMilliseconds(
           kDebounceTimeoutMilliseconds), this,
           &SettingGetterImplKDE::OnDebouncedNotification);
     }
   }
 
-  typedef std::map<Setting, std::string> string_map_type;
-  typedef std::map<Setting, std::vector<std::string> > strings_map_type;
+  typedef std::map<StringSetting, std::string> string_map_type;
+  typedef std::map<StringListSetting,
+                   std::vector<std::string> > strings_map_type;
 
   int inotify_fd_;
   base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   base::OneShotTimer<SettingGetterImplKDE> debounce_timer_;
   FilePath kde_config_dir_;
   bool indirect_manual_;
   bool auto_no_pac_;
   bool reversed_bypass_list_;
   // We don't own |env_var_getter_|.  It's safe to hold a pointer to it, since
   // both it and us are owned by ProxyConfigServiceLinux::Delegate, and have the
   // same lifetime.
   base::Environment* env_var_getter_;
 
   // We cache these settings whenever we re-read the kioslaverc file.
   string_map_type string_table_;
   strings_map_type strings_table_;
 
   // Message loop of the file thread, for reading kioslaverc. If NULL,
   // just read it directly (for testing). We also handle inotify events
   // on this thread.
   MessageLoopForIO* file_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplKDE);
 };
 
 }  // namespace
 
 bool ProxyConfigServiceLinux::Delegate::GetProxyFromSettings(
-    SettingGetter::Setting host_key,
+    SettingGetter::StringSetting host_key,
     ProxyServer* result_server) {
   std::string host;
   if (!setting_getter_->GetString(host_key, &host) || host.empty()) {
     // Unset or empty.
     return false;
   }
   // Check for an optional port.
   int port = 0;
-  SettingGetter::Setting port_key =
+  SettingGetter::IntSetting port_key =
       SettingGetter::HostSettingToPortSetting(host_key);
   setting_getter_->GetInt(port_key, &port);
   if (port != 0) {
     // If a port is set and non-zero:
     host += ":" + base::IntToString(port);
   }
 
   // gconf settings do not appear to distinguish between SOCKS version. We
   // default to version 5. For more information on this policy decision, see:
   // http://code.google.com/p/chromium/issues/detail?id=55912#c2
@@ skipping 385 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net