Whenever proxy configurations contain socks and http/https/ftp proxies, socks...

net/proxy/proxy_config.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef NET_PROXY_PROXY_CONFIG_H_
 #define NET_PROXY_PROXY_CONFIG_H_
 
 #include <ostream>
 #include <string>
 #include <vector>
@@ skipping 50 matching lines @@
     //   <url-scheme>"="<proxy-uri>
     //
     // For example:
     //   "http=foopy:80;ftp=foopy2"  -- use HTTP proxy "foopy:80" for http URLs,
     //                                  and HTTP proxy "foopy2:80" for ftp URLs.
     //   "foopy:80"                  -- use HTTP proxy "foopy:80" for all URLs.
     //   "socks4://foopy"            -- use SOCKS v4 proxy "foopy:1080" for all
     //                                  URLs.
     void ParseFromString(const std::string& proxy_rules);
 
-    // Returns one of {&proxy_for_http, &proxy_for_https, &proxy_for_ftp},
-    // or NULL if it is a scheme that we don't have a mapping for. Should only
-    // call this if the type is TYPE_PROXY_PER_SCHEME.
-    const ProxyServer* MapSchemeToProxy(const std::string& scheme) const;
+    // Returns one of {&proxy_for_http, &proxy_for_https, &proxy_for_ftp,
+    // &socks_proxy}, or NULL if it is a scheme that we don't have a mapping
+    // for. If the scheme mapping is not present and socks_proxy is defined,
+    // we fall back to using socks_proxy.
+    // Should only call this if the type is TYPE_PROXY_PER_SCHEME.
+    const ProxyServer* MapUrlSchemeToProxy(const std::string& url_scheme) const;
 
     bool operator==(const ProxyRules& other) const {
       return type == other.type &&
              single_proxy == other.single_proxy &&
              proxy_for_http == other.proxy_for_http &&
              proxy_for_https == other.proxy_for_https &&
-             proxy_for_ftp == other.proxy_for_ftp;
+             proxy_for_ftp == other.proxy_for_ftp &&
+             socks_proxy == other.socks_proxy;
     }
 
     Type type;
 
     // Set if |type| is TYPE_SINGLE_PROXY.
     ProxyServer single_proxy;
 
     // Set if |type| is TYPE_PROXY_PER_SCHEME.
     ProxyServer proxy_for_http;
     ProxyServer proxy_for_https;
     ProxyServer proxy_for_ftp;
+
+    // Set if configuration has SOCKS proxy.
+    ProxyServer socks_proxy;
+   private:
+    // Returns one of {&proxy_for_http, &proxy_for_https, &proxy_for_ftp,
+    // &socks_proxy}, or NULL if it is a scheme that we don't have a mapping
+    // for. Should only call this if the type is TYPE_PROXY_PER_SCHEME.
+    ProxyServer* MapSchemeToProxy(const std::string& scheme);
   };
 
   ProxyRules proxy_rules;
 
   // Parses entries from a comma-separated list of hosts for which proxy
   // configurations should be bypassed. Clears proxy_bypass and sets it to the
   // resulting list.
   void ParseNoProxyList(const std::string& no_proxy);
 
   // Indicates a list of hosts that should bypass any proxy configuration.  For
@@ skipping 21 matching lines @@
 // Dumps a human-readable string representation of the configuration to |out|;
 // used when logging the configuration changes.
 std::ostream& operator<<(std::ostream& out, const net::ProxyConfig& config);
 
 // Dumps a human-readable string representation of the |rules| to |out|;
 // used for logging and for better unittest failure output.
 std::ostream& operator<<(std::ostream& out,
                          const net::ProxyConfig::ProxyRules& rules);
 
 #endif  // NET_PROXY_PROXY_CONFIG_H_