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

net/proxy/proxy_config.cc

 // 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.
 
 #include "net/proxy/proxy_config.h"
 
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 
 namespace net {
@@ skipping 18 matching lines @@
   return auto_detect || !pac_url.is_empty();
 }
 
 void ProxyConfig::ProxyRules::ParseFromString(const std::string& proxy_rules) {
   // Reset.
   type = TYPE_NO_RULES;
   single_proxy = ProxyServer();
   proxy_for_http = ProxyServer();
   proxy_for_https = ProxyServer();
   proxy_for_ftp = ProxyServer();
+  socks_proxy = ProxyServer();
 
   StringTokenizer proxy_server_list(proxy_rules, ";");
   while (proxy_server_list.GetNext()) {
     StringTokenizer proxy_server_for_scheme(
         proxy_server_list.token_begin(), proxy_server_list.token_end(), "=");
 
     while (proxy_server_for_scheme.GetNext()) {
       std::string url_scheme = proxy_server_for_scheme.token();
 
       // If we fail to get the proxy server here, it means that
       // this is a regular proxy server configuration, i.e. proxies
       // are not configured per protocol.
       if (!proxy_server_for_scheme.GetNext()) {
         if (type == TYPE_PROXY_PER_SCHEME)
           continue;  // Unexpected.
-        single_proxy = ProxyServer::FromURI(url_scheme);
-        type = TYPE_SINGLE_PROXY;
-        return;
-      }
-
-      // If the proxy settings has only socks and others blank,
-      // make that the default for all the proxies
-      // This gets hit only on windows when using IE settings.
-      if (url_scheme == "socks") {
-        std::string proxy_server_string = "socks://";
-        proxy_server_string.append(proxy_server_for_scheme.token());
-        single_proxy = ProxyServer::FromURI(proxy_server_string);
+        single_proxy = ProxyServer::FromURI(url_scheme,
+                                            ProxyServer::SCHEME_HTTP);
         type = TYPE_SINGLE_PROXY;
         return;
       }
 
       // Trim whitespace off the url scheme.
       TrimWhitespaceASCII(url_scheme, TRIM_ALL, &url_scheme);
 
       // Add it to the per-scheme mappings (if supported scheme).
       type = TYPE_PROXY_PER_SCHEME;
-      if (const ProxyServer* entry = MapSchemeToProxy(url_scheme))
-        *const_cast<ProxyServer*>(entry) =
-            ProxyServer::FromURI(proxy_server_for_scheme.token());
+      if (ProxyServer* entry = MapSchemeToProxy(url_scheme)) {
+        std::string proxy_server_token = proxy_server_for_scheme.token();
+        ProxyServer::Scheme scheme = (entry == &socks_proxy) ?
+            ProxyServer::SCHEME_SOCKS4 : ProxyServer::SCHEME_HTTP;
+        *entry = ProxyServer::FromURI(proxy_server_token, scheme);
+      }
     }
   }
 }
 
-const ProxyServer* ProxyConfig::ProxyRules::MapSchemeToProxy(
-    const std::string& scheme) const {
+const ProxyServer* ProxyConfig::ProxyRules::MapUrlSchemeToProxy(
+    const std::string& url_scheme) const {
+  const ProxyServer* proxy_server =
+      const_cast<ProxyRules*>(this)->MapSchemeToProxy(url_scheme);
+  if (proxy_server && proxy_server->is_valid())
+    return proxy_server;
+  if (socks_proxy.is_valid())
+    return &socks_proxy;
+  return NULL;  // No mapping for this scheme. Use direct.
+}
+
+ProxyServer* ProxyConfig::ProxyRules::MapSchemeToProxy(
+    const std::string& scheme) {
   DCHECK(type == TYPE_PROXY_PER_SCHEME);
   if (scheme == "http")
     return &proxy_for_http;
   if (scheme == "https")
     return &proxy_for_https;
   if (scheme == "ftp")
     return &proxy_for_ftp;
+  if (scheme == "socks")
+    return &socks_proxy;
   return NULL;  // No mapping for this scheme.
 }
 
 namespace {
 
 // Returns true if the given string represents an IP address.
 bool IsIPAddress(const std::string& domain) {
   // From GURL::HostIsIPAddress()
   url_canon::RawCanonOutputT<char, 128> ignored_output;
   url_canon::CanonHostInfo host_info;
@@ skipping 86 matching lines @@
     default:
       type = IntToString(rules.type);
       break;
   }
   return out << "  {\n"
              << "    type: " << type << "\n"
              << "    single_proxy: " << rules.single_proxy << "\n"
              << "    proxy_for_http: " << rules.proxy_for_http << "\n"
              << "    proxy_for_https: " << rules.proxy_for_https << "\n"
              << "    proxy_for_ftp: " << rules.proxy_for_ftp << "\n"
+             << "    socks_proxy: " << rules.socks_proxy << "\n"
              << "  }";
 }
 
 std::ostream& operator<<(std::ostream& out, const net::ProxyConfig& config) {
   out << "{\n"
       << "  auto_detect: " << config.auto_detect << "\n"
       << "  pac_url: " << config.pac_url << "\n"
       << "  proxy_rules:\n" << config.proxy_rules << "\n"
       << "  proxy_bypass_local_names: " << config.proxy_bypass_local_names
       << "\n"
       << "  proxy_bypass_list:\n";
 
   // Print out the proxy bypass list.
   if (!config.proxy_bypass.empty()) {
     out << "  {\n";
     std::vector<std::string>::const_iterator it;
     for (it = config.proxy_bypass.begin();
          it != config.proxy_bypass.end(); ++it) {
       out << "    " << *it << "\n";
     }
     out << "  }\n";
   }
 
   out << "  id: " << config.id() << "\n"
       << "}";
   return out;
 }